pidgin3: comparison libpurple/protocols/myspace/myspace.c

-:34813ddd7169
+:077b4d6fc595
-/* MySpaceIM Protocol Plugin
+/**
+* MySpaceIM Protocol Plugin
 *
 * \author Jeff Connelly
 *
 * Copyright (C) 2007, Jeff Connelly <jeff2@soc.pidgin.im>
 *
 #define PURPLE_PLUGIN
 #include "myspace.h"
-/* Internal functions */
+static void msim_set_status(PurpleAccount *account, PurpleStatus *status);
+static void msim_set_idle(PurpleConnection *gc, int time);
-#ifdef MSIM_DEBUG_MSG
-static void print_hash_item(gpointer key, gpointer value, gpointer user_data);
+/**
-#endif
+* Perform actual postprocessing on a message, adding userid as specified.
+*
-static int msim_send_really_raw(PurpleConnection *gc, const char *buf, int total_bytes);
+* @param msg The message to postprocess.
-static gboolean msim_login_challenge(MsimSession *session, MsimMessage *msg);
+* @param uid_before Name of field where to insert new field before, or NULL for end.
-static gchar *msim_compute_login_response(const gchar nonce[2 * NONCE_SIZE], const gchar *email, const gchar *password, guint *response_len);
+* @param uid_field_name Name of field to add uid to.
+* @param uid The userid to insert.
-static gboolean msim_incoming_bm_record_cv(MsimSession *session, MsimMessage *msg);
+*
-static gboolean msim_incoming_bm(MsimSession *session, MsimMessage *msg);
+* If the field named by uid_field_name already exists, then its string contents will
-static gboolean msim_incoming_status(MsimSession *session, MsimMessage *msg);
+* be used for the field, except "<uid>" will be replaced by the userid.
-static gboolean msim_incoming_im(MsimSession *session, MsimMessage *msg);
+*
-/* static gboolean msim_incoming_zap(MsimSession *session, MsimMessage *msg); - in zap.c */
+* If the field named by uid_field_name does not exist, it will be added before the
-static gboolean msim_incoming_action(MsimSession *session, MsimMessage *msg);
+* field named by uid_before, as an integer, with the userid.
-static gboolean msim_incoming_media(MsimSession *session, MsimMessage *msg);
+*
-static gboolean msim_incoming_unofficial_client(MsimSession *session,
+* Does not handle sending, or scheduling userid lookup. For that, see msim_postprocess_outgoing().
-		MsimMessage *msg);
+*/
+static MsimMessage *
-#ifdef MSIM_SEND_CLIENT_VERSION
+msim_do_postprocessing(MsimMessage *msg, const gchar *uid_before,
-static gboolean msim_send_unofficial_client(MsimSession *session, gchar *username);
+		const gchar *uid_field_name, guint uid)
-#endif
+{
+	MsimMessageElement *elem;
-static void msim_get_info_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+	msim_msg_dump("msim_do_postprocessing msg: %s\n", msg);
-static void msim_set_status_code(MsimSession *session, guint code, gchar *statstring);
+	/* First, check - if the field already exists, replace <uid> within it */
+	if ((elem = msim_msg_get(msg, uid_field_name)) != NULL) {
-static gboolean msim_process_server_info(MsimSession *session, MsimMessage *msg);
+		gchar *fmt_string;
-static gboolean msim_web_challenge(MsimSession *session, MsimMessage *msg);
+		gchar *uid_str, *new_str;
-static gboolean msim_process_reply(MsimSession *session, MsimMessage *msg);
+		/* Get the packed element, flattening it. This allows <uid> to be
-static gboolean msim_preprocess_incoming(MsimSession *session, MsimMessage *msg);
+		 * replaced within nested data structures, since the replacement is done
+		 * on the linear, packed data, not on a complicated data structure.
-#ifdef MSIM_USE_KEEPALIVE
+		 *
-static gboolean msim_check_alive(gpointer data);
+		 * For example, if the field was originally a dictionary or a list, you
-#endif
+		 * would have to iterate over all the items in it to see what needs to
+		 * be replaced. But by packing it first, the <uid> marker is easily replaced
-static gboolean msim_is_username_set(MsimSession *session, MsimMessage *msg);
+		 * just by a string replacement.
+		 */
-static gboolean msim_process(MsimSession *session, MsimMessage *msg);
+		fmt_string = msim_msg_pack_element_data(elem);
-static MsimMessage *msim_do_postprocessing(MsimMessage *msg, const gchar *uid_field_name, const gchar *uid_before, guint uid);
+		uid_str = g_strdup_printf("%d", uid);
-static void msim_postprocess_outgoing_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+		new_str = purple_strreplace(fmt_string, "<uid>", uid_str);
-static gboolean msim_postprocess_outgoing(MsimSession *session, MsimMessage *msg, const gchar *username, const gchar *uid_field_name, const gchar *uid_before);
+		g_free(uid_str);
+		g_free(fmt_string);
-static gboolean msim_error(MsimSession *session, MsimMessage *msg);
+		/* Free the old element data */
-static void msim_check_inbox_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+		msim_msg_free_element_data(elem->data);
-static gboolean msim_check_inbox(gpointer data);
+		/* Replace it with our new data */
-static void msim_input_cb(gpointer gc_uncasted, gint source, PurpleInputCondition cond);
+		elem->data = new_str;
+		elem->type = MSIM_TYPE_RAW;
-static void msim_connect_cb(gpointer data, gint source, const gchar *error_message);
+	} else {
+		/* Otherwise, insert new field into outgoing message. */
-static void msim_import_friends(PurplePluginAction *action);
+		msg = msim_msg_insert_before(msg, uid_before, uid_field_name, MSIM_TYPE_INTEGER, GUINT_TO_POINTER(uid));
-static void msim_import_friends_cb(MsimSession *session, MsimMessage *reply, gpointer user_data);
+	}
-static gboolean msim_get_contact_list(MsimSession *session, int what_to_do_after);
+	msim_msg_dump("msim_postprocess_outgoing_cb: postprocessed msg=%s\n", msg);
-static gboolean msim_uri_handler(const gchar *proto, const gchar *cmd, GHashTable *params);
-static void msim_uri_handler_addContact_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+	return msg;
-static void msim_uri_handler_sendIM_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+}
 /**
-* Load the plugin.
+* Callback for msim_postprocess_outgoing() to add a userid to a message, and send it (once receiving userid).
-*/
+*
-gboolean
+* @param session
-msim_load(PurplePlugin *plugin)
+* @param userinfo The user information reply message, containing the user ID
-{
+* @param data The message to postprocess and send.
-	/* If compiled to use RC4 from libpurple, check if it is really there. */
+*
-	if (!purple_ciphers_find_cipher("rc4")) {
+* The data message should contain these fields:
-		purple_debug_error("msim", "rc4 not in libpurple, but it is required - not loading MySpaceIM plugin!\n");
+*
-		purple_notify_error(plugin, _("Missing Cipher"),
+*  _uid_field_name: string, name of field to add with userid from userinfo message
-				_("The RC4 cipher could not be found"),
+*  _uid_before: string, name of field before field to insert, or NULL for end
-				_("Upgrade "
+*/
-					"to a libpurple with RC4 support (>= 2.0.1). MySpaceIM "
+static void
-					"plugin will not be loaded."));
+msim_postprocess_outgoing_cb(MsimSession *session, MsimMessage *userinfo,
-		return FALSE;
+		gpointer data)
-	}
+{
-	return TRUE;
+	gchar *uid_field_name, *uid_before, *username;
+	guint uid;
+	MsimMessage *msg, *body;
+	msg = (MsimMessage *)data;
+	msim_msg_dump("msim_postprocess_outgoing_cb() got msg=%s\n", msg);
+	/* Obtain userid from userinfo message. */
+	body = msim_msg_get_dictionary(userinfo, "body");
+	g_return_if_fail(body != NULL);
+	uid = msim_msg_get_integer(body, "UserID");
+	msim_msg_free(body);
+	username = msim_msg_get_string(msg, "_username");
+	if (!uid) {
+		gchar *msg;
+		msg = g_strdup_printf(_("No such user: %s"), username);
+		if (!purple_conv_present_error(username, session->account, msg)) {
+			purple_notify_error(NULL, NULL, _("User lookup"), msg);
+		}
+		g_free(msg);
+		g_free(username);
+		/* TODO: free
+		 * msim_msg_free(msg);
+		 */
+		return;
+	}
+	uid_field_name = msim_msg_get_string(msg, "_uid_field_name");
+	uid_before = msim_msg_get_string(msg, "_uid_before");
+	msg = msim_do_postprocessing(msg, uid_before, uid_field_name, uid);
+	/* Send */
+	if (!msim_msg_send(session, msg)) {
+		msim_msg_dump("msim_postprocess_outgoing_cb: sending failed for message: %s\n", msg);
+	}
+	/* Free field names AFTER sending message, because MsimMessage does NOT copy
+	 * field names - instead, treats them as static strings (which they usually are).
+	 */
+	g_free(uid_field_name);
+	g_free(uid_before);
+	g_free(username);
+	/* TODO: free
+	 * msim_msg_free(msg);
+	 */
+}
+/**
+* Postprocess and send a message.
+*
+* @param session
+* @param msg Message to postprocess. Will NOT be freed.
+* @param username Username to resolve. Assumed to be a static string (will not be freed or copied).
+* @param uid_field_name Name of new field to add, containing uid of username. Static string.
+* @param uid_before Name of existing field to insert username field before. Static string.
+*
+* @return TRUE if successful.
+*/
+static gboolean
+msim_postprocess_outgoing(MsimSession *session, MsimMessage *msg,
+		const gchar *username, const gchar *uid_field_name,
+		const gchar *uid_before)
+{
+	PurpleBuddy *buddy;
+	guint uid;
+	gboolean rc;
+	g_return_val_if_fail(msg != NULL, FALSE);
+	/* Store information for msim_postprocess_outgoing_cb(). */
+	msim_msg_dump("msim_postprocess_outgoing: msg before=%s\n", msg);
+	msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, g_strdup(username));
+	msg = msim_msg_append(msg, "_uid_field_name", MSIM_TYPE_STRING, g_strdup(uid_field_name));
+	msg = msim_msg_append(msg, "_uid_before", MSIM_TYPE_STRING, g_strdup(uid_before));
+	/* First, try the most obvious. If numeric userid is given, use that directly. */
+	if (msim_is_userid(username)) {
+		uid = atol(username);
+	} else {
+		/* Next, see if on buddy list and know uid. */
+		buddy = purple_find_buddy(session->account, username);
+		if (buddy) {
+			uid = purple_blist_node_get_int(&buddy->node, "UserID");
+		} else {
+			uid = 0;
+		}
+		if (!buddy || !uid) {
+			/* Don't have uid offhand - need to ask for it, and wait until hear back before sending. */
+			purple_debug_info("msim", ">>> msim_postprocess_outgoing: couldn't find username %s in blist\n",
+					username ? username : "(NULL)");
+			msim_msg_dump("msim_postprocess_outgoing - scheduling lookup, msg=%s\n", msg);
+			/* TODO: where is cloned message freed? Should be in _cb. */
+			msim_lookup_user(session, username, msim_postprocess_outgoing_cb, msim_msg_clone(msg));
+			return TRUE;       /* not sure of status yet - haven't sent! */
+		}
+	}
+	/* Already have uid, postprocess and send msg immediately. */
+	purple_debug_info("msim", "msim_postprocess_outgoing: found username %s has uid %d\n",
+			username ? username : "(NULL)", uid);
+	msg = msim_do_postprocessing(msg, uid_before, uid_field_name, uid);
+	msim_msg_dump("msim_postprocess_outgoing: msg after (uid immediate)=%s\n", msg);
+	rc = msim_msg_send(session, msg);
+	/* TODO: free
+	 * msim_msg_free(msg);
+	 */
+	return rc;
+}
+/**
+* Send a buddy message of a given type.
+*
+* @param session
+* @param who Username to send message to.
+* @param text Message text to send. Not freed; will be copied.
+* @param type A MSIM_BM_* constant.
+*
+* @return TRUE if success, FALSE if fail.
+*
+* Buddy messages ('bm') include instant messages, action messages, status messages, etc.
+*/
+gboolean
+msim_send_bm(MsimSession *session, const gchar *who, const gchar *text,
+		int type)
+{
+	gboolean rc;
+	MsimMessage *msg;
+	const gchar *from_username;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(who != NULL, FALSE);
+	g_return_val_if_fail(text != NULL, FALSE);
+	from_username = session->account->username;
+	g_return_val_if_fail(from_username != NULL, FALSE);
+	purple_debug_info("msim", "sending %d message from %s to %s: %s\n",
+				  type, from_username, who, text);
+	msg = msim_msg_new(
+			"bm", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(type),
+			"sesskey", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(session->sesskey),
+			/* 't' will be inserted here */
+			"cv", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(MSIM_CLIENT_VERSION),
+			"msg", MSIM_TYPE_STRING, g_strdup(text),
+			NULL);
+	rc = msim_postprocess_outgoing(session, msg, who, "t", "cv");
+	msim_msg_free(msg);
+	return rc;
+}
+/**
+* Lookup a username by userid, from buddy list.
+*
+* @param wanted_uid
+*
+* @return Username of wanted_uid, if on blist, or NULL.
+*         This is a static string, so don't free it. Copy it if needed.
+*
+*/
+static const gchar *
+msim_uid2username_from_blist(PurpleAccount *account, guint wanted_uid)
+{
+	GSList *buddies, *cur;
+	const gchar *ret;
+	buddies = purple_find_buddies(account, NULL);
+	if (!buddies)
+	{
+		purple_debug_info("msim", "msim_uid2username_from_blist: no buddies?\n");
+		return NULL;
+	}
+	ret = NULL;
+	for (cur = buddies; cur != NULL; cur = g_slist_next(cur))
+	{
+		PurpleBuddy *buddy;
+		guint uid;
+		const gchar *name;
+		/* See finch/gnthistory.c */
+		buddy = cur->data;
+		uid = purple_blist_node_get_int(&buddy->node, "UserID");
+		name = purple_buddy_get_name(buddy);
+		if (uid == wanted_uid)
+		{
+			ret = name;
+			break;
+		}
+	}
+	g_slist_free(buddies);
+	return ret;
+}
+/**
+* Setup a callback, to be called when a reply is received with the returned rid.
+*
+* @param cb The callback, an MSIM_USER_LOOKUP_CB.
+* @param data Arbitrary user data to be passed to callback (probably an MsimMessage *).
+*
+* @return The request/reply ID, used to link replies with requests, or -1.
+*          Put the rid in your request, 'rid' field.
+*
+* TODO: Make more generic and more specific:
+* 1) MSIM_USER_LOOKUP_CB - make it for PERSIST_REPLY, not just user lookup
+* 2) data - make it an MsimMessage?
+*/
+guint
+msim_new_reply_callback(MsimSession *session, MSIM_USER_LOOKUP_CB cb,
+		gpointer data)
+{
+	guint rid;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
+	rid = session->next_rid++;
+	g_hash_table_insert(session->user_lookup_cb, GUINT_TO_POINTER(rid), cb);
+	g_hash_table_insert(session->user_lookup_cb_data, GUINT_TO_POINTER(rid), data);
+	return rid;
+}
+/**
+* Return the icon name for a buddy and account.
+*
+* @param acct The account to find the icon for, or NULL for protocol icon.
+* @param buddy The buddy to find the icon for, or NULL for the account icon.
+*
+* @return The base icon name string.
+*/
+static const gchar *
+msim_list_icon(PurpleAccount *acct, PurpleBuddy *buddy)
+{
+	/* Use a MySpace icon submitted by hbons at
+	 * http://developer.pidgin.im/wiki/MySpaceIM. */
+	return "myspace";
+}
+/**
+* Obtain the status text for a buddy.
+*
+* @param buddy The buddy to obtain status text for.
+*
+* @return Status text, or NULL if error. Caller g_free()'s.
+*/
+static char *
+msim_status_text(PurpleBuddy *buddy)
+{
+	MsimSession *session;
+	MsimUser *user;
+	const gchar *display_name, *headline;
+	g_return_val_if_fail(buddy != NULL, NULL);
+	user = msim_get_user_from_buddy(buddy);
+	session = (MsimSession *)buddy->account->gc->proto_data;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), NULL);
+	display_name = headline = NULL;
+	/* Retrieve display name and/or headline, depending on user preference. */
+	if (purple_account_get_bool(session->account, "show_headline", TRUE)) {
+		headline = user->headline;
+	}
+	if (purple_account_get_bool(session->account, "show_display_name", FALSE)) {
+		display_name = user->display_name;
+	}
+	/* Return appropriate combination of display name and/or headline, or neither. */
+	if (display_name && headline) {
+		return g_strconcat(display_name, " ", headline, NULL);
+	} else if (display_name) {
+		return g_strdup(display_name);
+	} else if (headline) {
+		return g_strdup(headline);
+	}
+	return NULL;
+}
+/**
+* Obtain the tooltip text for a buddy.
+*
+* @param buddy Buddy to obtain tooltip text on.
+* @param user_info Variable modified to have the tooltip text.
+* @param full TRUE if should obtain full tooltip text.
+*/
+static void
+msim_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info,
+		gboolean full)
+{
+	MsimUser *user;
+	g_return_if_fail(buddy != NULL);
+	g_return_if_fail(user_info != NULL);
+	user = msim_get_user_from_buddy(buddy);
+	if (PURPLE_BUDDY_IS_ONLINE(buddy)) {
+		MsimSession *session;
+		session = (MsimSession *)buddy->account->gc->proto_data;
+		g_return_if_fail(MSIM_SESSION_VALID(session));
+		/* TODO: if (full), do something different? */
+		/* TODO: request information? have to figure out how to do
+		 * the asynchronous lookup like oscar does (tooltip shows
+		 * 'retrieving...' if not yet available, then changes when it is).
+		 *
+		 * Right now, only show what we have on hand.
+		 */
+		/* Show abbreviated user info. */
+		msim_append_user_info(session, user_info, user, FALSE);
+	}
 }
 /**
 * Get possible user status types. Based on mockprpl.
 *
 * @return GList of status types.
 */
-GList *
+static GList *
 msim_status_types(PurpleAccount *acct)
 {
 	GList *types;
 	PurpleStatusType *status;
 	return types;
 }
 /**
-* Return the icon name for a buddy and account.
+* Compute the base64'd login challenge response based on username, password, nonce, and IPs.
 *
-* @param acct The account to find the icon for, or NULL for protocol icon.
+* @param nonce The base64 encoded nonce ('nc') field from the server.
-* @param buddy The buddy to find the icon for, or NULL for the account icon.
+* @param email User's email address (used as login name).
-*
+* @param password User's cleartext password.
-* @return The base icon name string.
+* @param response_len Will be written with response length.
-*/
+*
-const gchar *
+* @return Binary login challenge response, ready to send to the server.
-msim_list_icon(PurpleAccount *acct, PurpleBuddy *buddy)
+* Must be g_free()'d when finished. NULL if error.
-{
+*/
-	/* Use a MySpace icon submitted by hbons at
+static gchar *
-	 * http://developer.pidgin.im/wiki/MySpaceIM. */
+msim_compute_login_response(const gchar nonce[2 * NONCE_SIZE],
-	return "myspace";
+		const gchar *email, const gchar *password, guint *response_len)
-}
+{
+	PurpleCipherContext *key_context;
-#ifdef MSIM_DEBUG_MSG
+	PurpleCipher *sha1;
-static void
+	PurpleCipherContext *rc4;
-print_hash_item(gpointer key, gpointer value, gpointer user_data)
-{
+	guchar hash_pw[HASH_SIZE];
-	purple_debug_info("msim", "%s=%s\n",
+	guchar key[HASH_SIZE];
-			key ? (gchar *)key : "(NULL)",
+	gchar *password_utf16le, *password_utf8_lc;
-			value ? (gchar *)value : "(NULL)");
+	guchar *data;
-}
+	guchar *data_out;
+	size_t data_len, data_out_len;
+	gsize conv_bytes_read, conv_bytes_written;
+	GError *conv_error;
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
+	int i;
 #endif
-/**
+	g_return_val_if_fail(nonce != NULL, NULL);
-* Send raw data (given as a NUL-terminated string) to the server.
+	g_return_val_if_fail(email != NULL, NULL);
-*
+	g_return_val_if_fail(password != NULL, NULL);
-* @param session
+	g_return_val_if_fail(response_len != NULL, NULL);
-* @param msg The raw data to send, in a NUL-terminated string.
-*
+	/* Convert password to lowercase (required for passwords containing
-* @return TRUE if succeeded, FALSE if not.
+	 * uppercase characters). MySpace passwords are lowercase,
-*
+	 * see ticket #2066. */
-*/
+	password_utf8_lc = g_utf8_strdown(password, -1);
-gboolean
-msim_send_raw(MsimSession *session, const gchar *msg)
+	/* Convert ASCII password to UTF16 little endian */
-{
+	purple_debug_info("msim", "converting password to UTF-16LE\n");
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	conv_error = NULL;
-	g_return_val_if_fail(msg != NULL, FALSE);
+	password_utf16le = g_convert(password_utf8_lc, -1, "UTF-16LE", "UTF-8",
+			&conv_bytes_read, &conv_bytes_written, &conv_error);
-	purple_debug_info("msim", "msim_send_raw: writing <%s>\n", msg);
+	g_free(password_utf8_lc);
-	return msim_send_really_raw(session->gc, msg, strlen(msg)) ==
+	g_return_val_if_fail(conv_bytes_read == strlen(password), NULL);
-		strlen(msg);
-}
+	if (conv_error != NULL) {
+		purple_debug_error("msim",
-/** Send raw data to the server, possibly with embedded NULs.
+				"g_convert password UTF8->UTF16LE failed: %s",
-*
+				conv_error->message);
-* Used in prpl_info struct, so that plugins can have the most possible
+		g_error_free(conv_error);
-* control of what is sent over the connection. Inside this prpl,
+		return NULL;
-* msim_send_raw() is used, since it sends NUL-terminated strings (easier).
+	}
-*
-* @param gc PurpleConnection
+	/* Compute password hash */
-* @param buf Buffer to send
+	purple_cipher_digest_region("sha1", (guchar *)password_utf16le,
-* @param total_bytes Size of buffer to send
+			conv_bytes_written, sizeof(hash_pw), hash_pw, NULL);
-*
+	g_free(password_utf16le);
-* @return Bytes successfully sent, or -1 on error.
-*/
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-static int
+	purple_debug_info("msim", "pwhash = ");
-msim_send_really_raw(PurpleConnection *gc, const char *buf, int total_bytes)
+	for (i = 0; i < sizeof(hash_pw); i++)
-{
+		purple_debug_info("msim", "%.2x ", hash_pw[i]);
-	int total_bytes_sent;
+	purple_debug_info("msim", "\n");
-	MsimSession *session;
+#endif
-	g_return_val_if_fail(gc != NULL, -1);
+	/* key = sha1(sha1(pw) + nonce2) */
-	g_return_val_if_fail(buf != NULL, -1);
+	sha1 = purple_ciphers_find_cipher("sha1");
-	g_return_val_if_fail(total_bytes >= 0, -1);
+	key_context = purple_cipher_context_new(sha1, NULL);
+	purple_cipher_context_append(key_context, hash_pw, HASH_SIZE);
-	session = (MsimSession *)gc->proto_data;
+	purple_cipher_context_append(key_context, (guchar *)(nonce + NONCE_SIZE), NONCE_SIZE);
+	purple_cipher_context_digest(key_context, sizeof(key), key, NULL);
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
+	purple_cipher_context_destroy(key_context);
-	/* Loop until all data is sent, or a failure occurs. */
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-	total_bytes_sent = 0;
+	purple_debug_info("msim", "key = ");
-	do {
+	for (i = 0; i < sizeof(key); i++) {
-		int bytes_sent;
+		purple_debug_info("msim", "%.2x ", key[i]);
+	}
-		bytes_sent = send(session->fd, buf + total_bytes_sent,
+	purple_debug_info("msim", "\n");
-				total_bytes - total_bytes_sent, 0);
+#endif
-		if (bytes_sent < 0) {
+	rc4 = purple_cipher_context_new_by_name("rc4", NULL);
-			purple_debug_info("msim", "msim_send_raw(%s): send() failed: %s\n",
-					buf, g_strerror(errno));
+	/* Note: 'key' variable is 0x14 bytes (from SHA-1 hash),
-			return total_bytes_sent;
+	 * but only first 0x10 used for the RC4 key. */
-		}
+	purple_cipher_context_set_option(rc4, "key_len", (gpointer)0x10);
-		total_bytes_sent += bytes_sent;
+	purple_cipher_context_set_key(rc4, key);
-	} while(total_bytes_sent < total_bytes);
+	/* TODO: obtain IPs of network interfaces */
-	return total_bytes_sent;
+	/* rc4 encrypt:
-}
+	 * nonce1+email+IP list */
+	data_len = NONCE_SIZE + strlen(email) + MSIM_LOGIN_IP_LIST_LEN;
-/**
+	data = g_new0(guchar, data_len);
-* Start logging in to the MSIM servers.
+	memcpy(data, nonce, NONCE_SIZE);
-*
+	memcpy(data + NONCE_SIZE, email, strlen(email));
-* @param acct Account information to use to login.
+	memcpy(data + NONCE_SIZE + strlen(email), MSIM_LOGIN_IP_LIST, MSIM_LOGIN_IP_LIST_LEN);
-*/
-void
+	data_out = g_new0(guchar, data_len);
-msim_login(PurpleAccount *acct)
-{
+	purple_cipher_context_encrypt(rc4, (const guchar *)data,
-	PurpleConnection *gc;
+			data_len, data_out, &data_out_len);
-	const gchar *host;
+	purple_cipher_context_destroy(rc4);
-	int port;
+	g_free(data);
-	g_return_if_fail(acct != NULL);
+	if (data_out_len != data_len) {
-	g_return_if_fail(acct->username != NULL);
+		purple_debug_info("msim", "msim_compute_login_response: "
+				"data length mismatch: %" G_GSIZE_FORMAT " != %"
-	purple_debug_info("msim", "logging in %s\n", acct->username);
+				G_GSIZE_FORMAT "\n", data_out_len, data_len);
+	}
-	gc = purple_account_get_connection(acct);
-	gc->proto_data = msim_session_new(acct);
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-	gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_URLDESC;
+	purple_debug_info("msim", "response=<%s>\n", data_out);
+#endif
-	/* 1. connect to server */
-	purple_connection_update_progress(gc, _("Connecting"),
+	*response_len = data_out_len;
-								  0,   /* which connection step this is */
-								  4);  /* total number of steps */
+	return (gchar *)data_out;
+}
-	host = purple_account_get_string(acct, "server", MSIM_SERVER);
-	port = purple_account_get_int(acct, "port", MSIM_PORT);
+/**
+* Process a login challenge, sending a response.
-	/* From purple.sf.net/api:
+*
-	 * """Note that this function name can be misleading--although it is called
+* @param session
-	 * "proxy connect," it is used for establishing any outgoing TCP connection,
-	 * whether through a proxy or not.""" */
-	/* Calls msim_connect_cb when connected. */
-	if (!purple_proxy_connect(gc, acct, host, port, msim_connect_cb, gc)) {
-		/* TODO: try other ports if in auto mode, then save
-		 * working port and try that first next time. */
-		purple_connection_error_reason (gc,
-			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
-			_("Couldn't create socket"));
-		return;
-	}
-}
-/**
-* Process a login challenge, sending a response.
-*
-* @param session
 * @param msg Login challenge message.
 *
 * @return TRUE if successful, FALSE if not
 */
 static gboolean
 msim_login_challenge(MsimSession *session, MsimMessage *msg)
 {
 	PurpleAccount *account;
 	gchar *response;
 	guint response_len;
 	gchar *nc;
 	return ret;
 }
 /**
-* Compute the base64'd login challenge response based on username, password, nonce, and IPs.
+* Process unrecognized information.
 *
-* @param nonce The base64 encoded nonce ('nc') field from the server.
+* @param session
-* @param email User's email address (used as login name).
+* @param msg An MsimMessage that was unrecognized, or NULL.
-* @param password User's cleartext password.
+* @param note Information on what was unrecognized, or NULL.
-* @param response_len Will be written with response length.
+*/
-*
+void
-* @return Binary login challenge response, ready to send to the server.
+msim_unrecognized(MsimSession *session, MsimMessage *msg, gchar *note)
-* Must be g_free()'d when finished. NULL if error.
+{
-*/
+	/* TODO: Some more context, outwardly equivalent to a backtrace,
-static gchar *
+	 * for helping figure out what this msg is for. What was going on?
-msim_compute_login_response(const gchar nonce[2 * NONCE_SIZE],
+	 * But not too much information so that a user
-		const gchar *email, const gchar *password, guint *response_len)
+	 * posting this dump reveals confidential information.
-{
+	 */
-	PurpleCipherContext *key_context;
-	PurpleCipher *sha1;
+	/* TODO: dump unknown msgs to file, so user can send them to me
-	PurpleCipherContext *rc4;
+	 * if they wish, to help add support for new messages (inspired
+	 * by Alexandr Shutko, who maintains OSCAR protocol documentation).
-	guchar hash_pw[HASH_SIZE];
+	 *
-	guchar key[HASH_SIZE];
+	 * Filed enhancement ticket for libpurple as #4688.
-	gchar *password_utf16le, *password_utf8_lc;
+	 */
-	guchar *data;
-	guchar *data_out;
+	purple_debug_info("msim", "Unrecognized data on account for %s\n",
-	size_t data_len, data_out_len;
+			(session && session->account && session->account->username) ?
-	gsize conv_bytes_read, conv_bytes_written;
+			session->account->username : "(NULL)");
-	GError *conv_error;
+	if (note) {
-#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
+		purple_debug_info("msim", "(Note: %s)\n", note);
-	int i;
+	}
+	if (msg) {
+		msim_msg_dump("Unrecognized message dump: %s\n", msg);
+	}
+}
+/** Called when the session key arrives to check whether the user
+* has a username, and set one if desired. */
+static gboolean
+msim_is_username_set(MsimSession *session, MsimMessage *msg)
+{
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+	g_return_val_if_fail(session->gc != NULL, FALSE);
+	session->sesskey = msim_msg_get_integer(msg, "sesskey");
+	purple_debug_info("msim", "SESSKEY=<%d>\n", session->sesskey);
+	/* What is proof? Used to be uid, but now is 52 base64'd bytes... */
+	/* Comes with: proof,profileid,userid,uniquenick -- all same values
+	 * some of the time, but can vary. This is our own user ID. */
+	session->userid = msim_msg_get_integer(msg, "userid");
+	/* Save uid to account so this account can be looked up by uid. */
+	purple_account_set_int(session->account, "uid", session->userid);
+	/* Not sure what profileid is used for. */
+	if (msim_msg_get_integer(msg, "profileid") != session->userid) {
+		msim_unrecognized(session, msg,
+				"Profile ID didn't match user ID, don't know why");
+	}
+	/* We now know are our own username, only after we're logged in..
+	 * which is weird, but happens because you login with your email
+	 * address and not username. Will be freed in msim_session_destroy(). */
+	session->username = msim_msg_get_string(msg, "uniquenick");
+	/* If user lacks a username, help them get one. */
+	if (msim_msg_get_integer(msg, "uniquenick") == session->userid) {
+		purple_debug_info("msim_is_username_set", "no username is set\n");
+		purple_request_yes_no(session->gc,
+			_("MySpaceIM - No Username Set"),
+			_("You appear to have no MySpace username."),
+			_("Would you like to set one now? (Note: THIS CANNOT BE CHANGED!)"),
+			0,
+			session->account,
+			NULL,
+			NULL,
+			session->gc,
+			G_CALLBACK(msim_set_username_cb),
+			G_CALLBACK(msim_do_not_set_username_cb));
+		purple_debug_info("msim_is_username_set","'username not set' alert prompted\n");
+		return FALSE;
+	}
+	return TRUE;
+}
+#ifdef MSIM_USE_KEEPALIVE
+/**
+* Check if the connection is still alive, based on last communication.
+*/
+static gboolean
+msim_check_alive(gpointer data)
+{
+	MsimSession *session;
+	time_t delta;
+	session = (MsimSession *)data;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	delta = time(NULL) - session->last_comm;
+	/* purple_debug_info("msim", "msim_check_alive: delta=%d\n", delta); */
+	if (delta >= MSIM_KEEPALIVE_INTERVAL) {
+		purple_debug_info("msim",
+				"msim_check_alive: %zu > interval of %d, presumed dead\n",
+				delta, MSIM_KEEPALIVE_INTERVAL);
+		purple_connection_error_reason(session->gc,
+				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
+				_("Lost connection with server"));
+		return FALSE;
+	}
+	return TRUE;
+}
 #endif
-	g_return_val_if_fail(nonce != NULL, NULL);
+/**
-	g_return_val_if_fail(email != NULL, NULL);
+* Handle mail reply checks.
-	g_return_val_if_fail(password != NULL, NULL);
+*/
-	g_return_val_if_fail(response_len != NULL, NULL);
+static void
+msim_check_inbox_cb(MsimSession *session, MsimMessage *reply, gpointer data)
-	/* Convert password to lowercase (required for passwords containing
+{
-	 * uppercase characters). MySpace passwords are lowercase,
+	MsimMessage *body;
-	 * see ticket #2066. */
+	guint old_inbox_status;
-	password_utf8_lc = g_utf8_strdown(password, -1);
+	guint i, n;
+	const gchar *froms[5], *tos[5], *urls[5], *subjects[5];
-	/* Convert ASCII password to UTF16 little endian */
-	purple_debug_info("msim", "converting password to UTF-16LE\n");
+	/* Information for each new inbox message type. */
-	conv_error = NULL;
+	static struct
-	password_utf16le = g_convert(password_utf8_lc, -1, "UTF-16LE", "UTF-8",
+	{
-			&conv_bytes_read, &conv_bytes_written, &conv_error);
+		const gchar *key;
-	g_free(password_utf8_lc);
+		guint bit;
+		const gchar *url;
-	g_return_val_if_fail(conv_bytes_read == strlen(password), NULL);
+		const gchar *text;
+	} message_types[] = {
-	if (conv_error != NULL) {
+		{ "Mail", MSIM_INBOX_MAIL, "http://messaging.myspace.com/index.cfm?fuseaction=mail.inbox", NULL },
-		purple_debug_error("msim",
+		{ "BlogComment", MSIM_INBOX_BLOG_COMMENT, "http://blog.myspace.com/index.cfm?fuseaction=blog", NULL },
-				"g_convert password UTF8->UTF16LE failed: %s",
+		{ "ProfileComment", MSIM_INBOX_PROFILE_COMMENT, "http://home.myspace.com/index.cfm?fuseaction=user", NULL },
-				conv_error->message);
+		{ "FriendRequest", MSIM_INBOX_FRIEND_REQUEST, "http://messaging.myspace.com/index.cfm?fuseaction=mail.friendRequests", NULL },
-		g_error_free(conv_error);
+		{ "PictureComment", MSIM_INBOX_PICTURE_COMMENT, "http://home.myspace.com/index.cfm?fuseaction=user", NULL }
-		return NULL;
+	};
-	}
+	/* Can't write _()'d strings in array initializers. Workaround. */
-	/* Compute password hash */
+	message_types[0].text = _("New mail messages");
-	purple_cipher_digest_region("sha1", (guchar *)password_utf16le,
+	message_types[1].text = _("New blog comments");
-			conv_bytes_written, sizeof(hash_pw), hash_pw, NULL);
+	message_types[2].text = _("New profile comments");
-	g_free(password_utf16le);
+	message_types[3].text = _("New friend requests!");
+	message_types[4].text = _("New picture comments");
-#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-	purple_debug_info("msim", "pwhash = ");
+	g_return_if_fail(reply != NULL);
-	for (i = 0; i < sizeof(hash_pw); i++)
-		purple_debug_info("msim", "%.2x ", hash_pw[i]);
+	msim_msg_dump("msim_check_inbox_cb: reply=%s\n", reply);
-	purple_debug_info("msim", "\n");
+	body = msim_msg_get_dictionary(reply, "body");
+	if (body == NULL)
+		return;
+	old_inbox_status = session->inbox_status;
+	n = 0;
+	for (i = 0; i < sizeof(message_types) / sizeof(message_types[0]); ++i) {
+		const gchar *key;
+		guint bit;
+		key = message_types[i].key;
+		bit = message_types[i].bit;
+		if (msim_msg_get(body, key)) {
+			/* Notify only on when _changes_ from no mail -> has mail
+			 * (edge triggered) */
+			if (!(session->inbox_status & bit)) {
+				purple_debug_info("msim", "msim_check_inbox_cb: got %s, at %d\n",
+						key ? key : "(NULL)", n);
+				subjects[n] = message_types[i].text;
+				froms[n] = _("MySpace");
+				tos[n] = session->username;
+				/* TODO: append token, web challenge, so automatically logs in.
+				 * Would also need to free strings because they won't be static
+				 */
+				urls[n] = message_types[i].url;
+				++n;
+			} else {
+				purple_debug_info("msim",
+						"msim_check_inbox_cb: already notified of %s\n",
+						key ? key : "(NULL)");
+			}
+			session->inbox_status |= bit;
+		}
+	}
+	if (n) {
+		purple_debug_info("msim",
+				"msim_check_inbox_cb: notifying of %d\n", n);
+		/* TODO: free strings with callback _if_ change to dynamic (w/ token) */
+		purple_notify_emails(session->gc,         /* handle */
+				n,                        /* count */
+				TRUE,                     /* detailed */
+				subjects, froms, tos, urls,
+				NULL,                     /* PurpleNotifyCloseCallback cb */
+				NULL);                    /* gpointer user_data */
+	}
+	msim_msg_free(body);
+}
+/**
+* Send request to check if there is new mail.
+*/
+static gboolean
+msim_check_inbox(gpointer data)
+{
+	MsimSession *session;
+	session = (MsimSession *)data;
+	if (!MSIM_SESSION_VALID(session)) {
+		purple_debug_info("msim", "msim_check_inbox: session invalid, stopping the mail check.\n");
+		return FALSE;
+	}
+	purple_debug_info("msim", "msim_check_inbox: checking mail\n");
+	g_return_val_if_fail(msim_send(session,
+			"persist", MSIM_TYPE_INTEGER, 1,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_GET,
+			"dsn", MSIM_TYPE_INTEGER, MG_CHECK_MAIL_DSN,
+			"lid", MSIM_TYPE_INTEGER, MG_CHECK_MAIL_LID,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"rid", MSIM_TYPE_INTEGER,
+				msim_new_reply_callback(session, msim_check_inbox_cb, NULL),
+			"body", MSIM_TYPE_STRING, g_strdup(""),
+			NULL), TRUE);
+	/* Always return true, so that we keep checking for mail. */
+	return TRUE;
+}
+/**
+* Add contact from server to buddy list, after looking up username.
+* Callback from msim_add_contact_from_server().
+*
+* @param data An MsimMessage * of the contact information. Will be freed.
+*/
+static void
+msim_add_contact_from_server_cb(MsimSession *session, MsimMessage *user_lookup_info, gpointer data)
+{
+	MsimMessage *contact_info, *user_lookup_info_body;
+	PurpleGroup *group;
+	PurpleBuddy *buddy;
+	MsimUser *user;
+	gchar *username, *group_name;
+	guint uid;
+	contact_info = (MsimMessage *)data;
+	purple_debug_info("msim_add_contact_from_server_cb", "contact_info addr=%p\n", contact_info);
+	uid = msim_msg_get_integer(contact_info, "ContactID");
+	if (!user_lookup_info) {
+		username = g_strdup(msim_uid2username_from_blist(session->account, uid));
+		g_return_if_fail(username != NULL);
+	} else {
+		user_lookup_info_body = msim_msg_get_dictionary(user_lookup_info, "body");
+		username = msim_msg_get_string(user_lookup_info_body, "UserName");
+		msim_msg_free(user_lookup_info_body);
+		g_return_if_fail(username != NULL);
+	}
+	purple_debug_info("msim_add_contact_from_server_cb",
+			"*** about to add/update username=%s\n", username);
+	/* 1. Creates a new group, or gets existing group if it exists (or so
+	 * the documentation claims). */
+	group_name = msim_msg_get_string(contact_info, "GroupName");
+	if (!group_name || (*group_name == '\0')) {
+		g_free(group_name);
+		group_name = g_strdup(_("IM Friends"));
+		purple_debug_info("myspace", "No GroupName specified, defaulting to '%s'.\n", group_name);
+	}
+	group = purple_find_group(group_name);
+	if (!group) {
+		group = purple_group_new(group_name);
+		/* Add group to beginning. See #2752. */
+		purple_blist_add_group(group, NULL);
+	}
+	g_free(group_name);
+	/* 2. Get or create buddy */
+	buddy = purple_find_buddy(session->account, username);
+	if (!buddy) {
+		purple_debug_info("msim_add_contact_from_server_cb",
+				"creating new buddy: %s\n", username);
+		buddy = purple_buddy_new(session->account, username, NULL);
+	}
+	/* TODO: use 'Position' in contact_info to take into account where buddy is */
+	purple_blist_add_buddy(buddy, NULL, group, NULL /* insertion point */);
+	/* 3. Update buddy information */
+	user = msim_get_user_from_buddy(buddy);
+	user->id = uid;
+	/* Keep track of the user ID across sessions */
+	purple_blist_node_set_int(&buddy->node, "UserID", uid);
+	/* Stores a few fields in the MsimUser, relevant to the buddy itself.
+	 * AvatarURL, Headline, ContactID. */
+	msim_store_user_info(session, contact_info, NULL);
+	/* TODO: other fields, store in 'user' */
+	msim_msg_free(contact_info);
+	g_free(username);
+}
+/**
+* Add first ContactID in contact_info to buddy's list. Used to add
+* server-side buddies to client-side list.
+*
+* @return TRUE if added.
+*/
+static gboolean
+msim_add_contact_from_server(MsimSession *session, MsimMessage *contact_info)
+{
+	guint uid;
+	const gchar *username;
+	uid = msim_msg_get_integer(contact_info, "ContactID");
+	g_return_val_if_fail(uid != 0, FALSE);
+	/* Lookup the username, since NickName and IMName is unreliable */
+	username = msim_uid2username_from_blist(session->account, uid);
+	if (!username) {
+		gchar *uid_str;
+		uid_str = g_strdup_printf("%d", uid);
+		purple_debug_info("msim_add_contact_from_server",
+				"contact_info addr=%p\n", contact_info);
+		msim_lookup_user(session, uid_str, msim_add_contact_from_server_cb, (gpointer)msim_msg_clone(contact_info));
+		g_free(uid_str);
+	} else {
+		msim_add_contact_from_server_cb(session, NULL, (gpointer)msim_msg_clone(contact_info));
+	}
+	/* Say that the contact was added, even if we're still looking up
+	 * their username. */
+	return TRUE;
+}
+/**
+* Called when contact list is received from server.
+*/
+static void
+msim_got_contact_list(MsimSession *session, MsimMessage *reply, gpointer user_data)
+{
+	MsimMessage *body, *body_node;
+	gchar *msg;
+	guint buddy_count;
+	msim_msg_dump("msim_got_contact_list: reply=%s", reply);
+	body = msim_msg_get_dictionary(reply, "body");
+	if (!body) {
+		/* No friends. Not an error. */
+		return;
+	}
+	buddy_count = 0;
+	for (body_node = body;
+		body_node != NULL;
+		body_node = msim_msg_get_next_element_node(body_node))
+	{
+		MsimMessageElement *elem;
+		elem = (MsimMessageElement *)body_node->data;
+		if (g_str_equal(elem->name, "ContactID"))
+		{
+			/* Will look for first contact in body_node */
+			if (msim_add_contact_from_server(session, body_node)) {
+				++buddy_count;
+			}
+		}
+	}
+	switch (GPOINTER_TO_UINT(user_data)) {
+		case MSIM_CONTACT_LIST_IMPORT_ALL_FRIENDS:
+		        msg = g_strdup_printf(ngettext("%d buddy was added or updated from the server (including buddies already on the server-side list)",
+						       "%d buddies were added or updated from the server (including buddies already on the server-side list)",
+						       buddy_count),
+					      buddy_count);
+			purple_notify_info(session->account, _("Add contacts from server"), msg, NULL);
+			g_free(msg);
+			break;
+		case MSIM_CONTACT_LIST_IMPORT_TOP_FRIENDS:
+			/* TODO */
+			break;
+		case MSIM_CONTACT_LIST_INITIAL_FRIENDS:
+			/* Nothing */
+			break;
+	}
+	msim_msg_free(body);
+}
+/**
+* Get contact list, calling msim_got_contact_list() with
+* what_to_do_after as user_data gpointer.
+*/
+static gboolean
+msim_get_contact_list(MsimSession *session, int what_to_do_after)
+{
+	return msim_send(session,
+			"persist", MSIM_TYPE_INTEGER, 1,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_GET,
+			"dsn", MSIM_TYPE_INTEGER, MG_LIST_ALL_CONTACTS_DSN,
+			"lid", MSIM_TYPE_INTEGER, MG_LIST_ALL_CONTACTS_LID,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"rid", MSIM_TYPE_INTEGER,
+				msim_new_reply_callback(session, msim_got_contact_list, GUINT_TO_POINTER(what_to_do_after)),
+			"body", MSIM_TYPE_STRING, g_strdup(""),
+			NULL);
+}
+/** Called after username is set, if necessary and we're open for business. */
+gboolean msim_we_are_logged_on(MsimSession *session)
+{
+	MsimMessage *body;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	/* The session is now set up, ready to be connected. This emits the
+	 * signedOn signal, so clients can now do anything with msimprpl, and
+	 * we're ready for it (session key, userid, username all setup). */
+	purple_connection_update_progress(session->gc, _("Connected"), 3, 4);
+	purple_connection_set_state(session->gc, PURPLE_CONNECTED);
+	/* Set display name to username (otherwise will show email address) */
+	purple_connection_set_display_name(session->gc, session->username);
+	body = msim_msg_new(
+			"UserID", MSIM_TYPE_INTEGER, session->userid,
+			NULL);
+	/* Request IM info about ourself. */
+	msim_send(session,
+			"persist", MSIM_TYPE_STRING, g_strdup("persist"),
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"dsn", MSIM_TYPE_INTEGER, MG_OWN_MYSPACE_INFO_DSN,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"lid", MSIM_TYPE_INTEGER, MG_OWN_MYSPACE_INFO_LID,
+			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
+			"body", MSIM_TYPE_DICTIONARY, body,
+			NULL);
+	/* Request MySpace info about ourself. */
+	msim_send(session,
+			"persist", MSIM_TYPE_STRING, g_strdup("persist"),
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"dsn", MSIM_TYPE_INTEGER, MG_OWN_IM_INFO_DSN,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"lid", MSIM_TYPE_INTEGER, MG_OWN_IM_INFO_LID,
+			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
+			"body", MSIM_TYPE_STRING, g_strdup(""),
+			NULL);
+	/* TODO: set options (persist cmd=514,dsn=1,lid=10) */
+	/* TODO: set blocklist */
+	/* Notify servers of our current status. */
+	purple_debug_info("msim", "msim_we_are_logged_on: notifying servers of status\n");
+	msim_set_status(session->account,
+			purple_account_get_active_status(session->account));
+	/* TODO: setinfo */
+	/*
+	body = msim_msg_new(
+		"TotalFriends", MSIM_TYPE_INTEGER, 666,
+		NULL);
+	msim_send(session,
+			"setinfo", MSIM_TYPE_BOOLEAN, TRUE,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"info", MSIM_TYPE_DICTIONARY, body,
+			NULL);
+			*/
+	/* Disable due to problems with timeouts. TODO: fix. */
+#ifdef MSIM_USE_KEEPALIVE
+	purple_timeout_add(MSIM_KEEPALIVE_INTERVAL_CHECK,
+			(GSourceFunc)msim_check_alive, session);
 #endif
-	/* key = sha1(sha1(pw) + nonce2) */
+	/* Check mail if they want to. */
-	sha1 = purple_ciphers_find_cipher("sha1");
+	if (purple_account_get_check_mail(session->account)) {
-	key_context = purple_cipher_context_new(sha1, NULL);
+		session->inbox_handle = purple_timeout_add(MSIM_MAIL_INTERVAL_CHECK,
-	purple_cipher_context_append(key_context, hash_pw, HASH_SIZE);
+				(GSourceFunc)msim_check_inbox, session);
-	purple_cipher_context_append(key_context, (guchar *)(nonce + NONCE_SIZE), NONCE_SIZE);
+		msim_check_inbox(session);
-	purple_cipher_context_digest(key_context, sizeof(key), key, NULL);
+	}
-	purple_cipher_context_destroy(key_context);
+	msim_get_contact_list(session, MSIM_CONTACT_LIST_INITIAL_FRIENDS);
-#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-	purple_debug_info("msim", "key = ");
+	return TRUE;
-	for (i = 0; i < sizeof(key); i++) {
+}
-		purple_debug_info("msim", "%.2x ", key[i]);
-	}
+/**
-	purple_debug_info("msim", "\n");
+* Record the client version in the buddy list, from an incoming message.
-#endif
+*/
-	rc4 = purple_cipher_context_new_by_name("rc4", NULL);
-	/* Note: 'key' variable is 0x14 bytes (from SHA-1 hash),
-	 * but only first 0x10 used for the RC4 key. */
-	purple_cipher_context_set_option(rc4, "key_len", (gpointer)0x10);
-	purple_cipher_context_set_key(rc4, key);
-	/* TODO: obtain IPs of network interfaces */
-	/* rc4 encrypt:
-	 * nonce1+email+IP list */
-	data_len = NONCE_SIZE + strlen(email) + MSIM_LOGIN_IP_LIST_LEN;
-	data = g_new0(guchar, data_len);
-	memcpy(data, nonce, NONCE_SIZE);
-	memcpy(data + NONCE_SIZE, email, strlen(email));
-	memcpy(data + NONCE_SIZE + strlen(email), MSIM_LOGIN_IP_LIST, MSIM_LOGIN_IP_LIST_LEN);
-	data_out = g_new0(guchar, data_len);
-	purple_cipher_context_encrypt(rc4, (const guchar *)data,
-			data_len, data_out, &data_out_len);
-	purple_cipher_context_destroy(rc4);
-	g_free(data);
-	if (data_out_len != data_len) {
-		purple_debug_info("msim", "msim_compute_login_response: "
-				"data length mismatch: %" G_GSIZE_FORMAT " != %"
-				G_GSIZE_FORMAT "\n", data_out_len, data_len);
-	}
-#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
-	purple_debug_info("msim", "response=<%s>\n", data_out);
-#endif
-	*response_len = data_out_len;
-	return (gchar *)data_out;
-}
-/**
-* Schedule an IM to be sent once the user ID is looked up.
-*
-* @param gc Connection.
-* @param who A user id, email, or username to send the message to.
-* @param message Instant message text to send.
-* @param flags Flags.
-*
-* @return 1 if successful or postponed, -1 if failed
-*
-* Allows sending to a user by username, email address, or userid. If
-* a username or email address is given, the userid must be looked up.
-* This function does that by calling msim_postprocess_outgoing().
-*/
-int
-msim_send_im(PurpleConnection *gc, const gchar *who, const gchar *message,
-		PurpleMessageFlags flags)
-{
-	MsimSession *session;
-	gchar *message_msim;
-	int rc;
-	g_return_val_if_fail(gc != NULL, -1);
-	g_return_val_if_fail(who != NULL, -1);
-	g_return_val_if_fail(message != NULL, -1);
-	/* 'flags' has many options, not used here. */
-	session = (MsimSession *)gc->proto_data;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
-	message_msim = html_to_msim_markup(session, message);
-	if (msim_send_bm(session, who, message_msim, MSIM_BM_INSTANT)) {
-		/* Return 1 to have Purple show this IM as being sent, 0 to not. I always
-		 * return 1 even if the message could not be sent, since I don't know if
-		 * it has failed yet--because the IM is only sent after the userid is
-		 * retrieved from the server (which happens after this function returns).
-		 * If an error does occur, it should be logged to the IM window.
-		 */
-		rc = 1;
-	} else {
-		rc = -1;
-	}
-	g_free(message_msim);
-	return rc;
-}
-/** Send a buddy message of a given type.
-*
-* @param session
-* @param who Username to send message to.
-* @param text Message text to send. Not freed; will be copied.
-* @param type A MSIM_BM_* constant.
-*
-* @return TRUE if success, FALSE if fail.
-*
-* Buddy messages ('bm') include instant messages, action messages, status messages, etc.
-*
-*/
-gboolean
-msim_send_bm(MsimSession *session, const gchar *who, const gchar *text,
-		int type)
-{
-	gboolean rc;
-	MsimMessage *msg;
-	const gchar *from_username;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	g_return_val_if_fail(who != NULL, FALSE);
-	g_return_val_if_fail(text != NULL, FALSE);
-	from_username = session->account->username;
-	g_return_val_if_fail(from_username != NULL, FALSE);
-	purple_debug_info("msim", "sending %d message from %s to %s: %s\n",
-				  type, from_username, who, text);
-	msg = msim_msg_new(
-			"bm", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(type),
-			"sesskey", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(session->sesskey),
-			/* 't' will be inserted here */
-			"cv", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(MSIM_CLIENT_VERSION),
-			"msg", MSIM_TYPE_STRING, g_strdup(text),
-			NULL);
-	rc = msim_postprocess_outgoing(session, msg, who, "t", "cv");
-	msim_msg_free(msg);
-	return rc;
-}
-/** Record the client version in the buddy list, from an incoming message. */
 static gboolean
 msim_incoming_bm_record_cv(MsimSession *session, MsimMessage *msg)
 {
 	gchar *username, *cv;
 	gboolean ret;
 	g_free(cv);
 	return ret;
 }
-/** Handle an incoming buddy message. */
+#ifdef MSIM_SEND_CLIENT_VERSION
+/**
+* Send our client version to another unofficial client that understands it.
+*/
+static gboolean
+msim_send_unofficial_client(MsimSession *session, gchar *username)
+{
+	gchar *our_info;
+	gboolean ret;
+	our_info = g_strdup_printf("Libpurple %d.%d.%d - msimprpl %s",
+			PURPLE_MAJOR_VERSION,
+			PURPLE_MINOR_VERSION,
+			PURPLE_MICRO_VERSION,
+			MSIM_PRPL_VERSION_STRING);
+	ret = msim_send_bm(session, username, our_info, MSIM_BM_UNOFFICIAL_CLIENT);
+	return ret;
+}
+#endif
+/**
+* Process incoming status messages.
+*
+* @param session
+* @param msg Status update message. Caller frees.
+*
+* @return TRUE if successful.
+*/
+static gboolean
+msim_incoming_status(MsimSession *session, MsimMessage *msg)
+{
+	PurpleBuddyList *blist;
+	MsimUser *user;
+	GList *list;
+	gchar *status_headline, *status_headline_escaped;
+	gint status_code, purple_status_code;
+	gchar *username;
+	gchar *unrecognized_msg;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+	msim_msg_dump("msim_status msg=%s\n", msg);
+	/* Helpfully looked up by msim_incoming_resolve() for us. */
+	username = msim_msg_get_string(msg, "_username");
+	g_return_val_if_fail(username != NULL, FALSE);
+	{
+		gchar *ss;
+		ss = msim_msg_get_string(msg, "msg");
+		purple_debug_info("msim",
+				"msim_status: updating status for <%s> to <%s>\n",
+				username, ss ? ss : "(NULL)");
+		g_free(ss);
+	}
+	/* Example fields:
+	 *  |s|0|ss|Offline
+	 *  |s|1|ss|:-)|ls||ip|0|p|0
+	 */
+	list = msim_msg_get_list(msg, "msg");
+	status_code = msim_msg_get_integer_from_element(g_list_nth_data(list, MSIM_STATUS_ORDINAL_ONLINE));
+	purple_debug_info("msim", "msim_status: %s's status code = %d\n", username, status_code);
+	status_headline = msim_msg_get_string_from_element(g_list_nth_data(list, MSIM_STATUS_ORDINAL_HEADLINE));
+	blist = purple_get_blist();
+	/* Add buddy if not found.
+	 * TODO: Could this be responsible for #3444? */
+	user = msim_find_user(session, username);
+	if (!user) {
+		PurpleBuddy *buddy;
+		purple_debug_info("msim",
+				"msim_status: making new buddy for %s\n", username);
+		buddy = purple_buddy_new(session->account, username, NULL);
+		purple_blist_add_buddy(buddy, NULL, NULL, NULL);
+		user = msim_get_user_from_buddy(buddy);
+		user->id = msim_msg_get_integer(msg, "f");
+		/* Keep track of the user ID across sessions */
+		purple_blist_node_set_int(&buddy->node, "UserID", user->id);
+		msim_store_user_info(session, msg, NULL);
+	} else {
+		purple_debug_info("msim", "msim_status: found buddy %s\n", username);
+	}
+	if (status_headline && strcmp(status_headline, "") != 0) {
+		/* The status headline is plaintext, but libpurple treats it as HTML,
+		 * so escape any HTML characters to their entity equivalents. */
+		status_headline_escaped = g_markup_escape_text(status_headline, strlen(status_headline));
+	} else {
+		status_headline_escaped = NULL;
+	}
+	g_free(status_headline);
+	if (user->headline)
+		g_free(user->headline);
+	/* don't copy; let the MsimUser own the headline, memory-wise */
+	user->headline = status_headline_escaped;
+	/* Set user status */
+	switch (status_code) {
+		case MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN:
+			purple_status_code = PURPLE_STATUS_OFFLINE;
+			break;
+		case MSIM_STATUS_CODE_ONLINE:
+			purple_status_code = PURPLE_STATUS_AVAILABLE;
+			break;
+		case MSIM_STATUS_CODE_AWAY:
+			purple_status_code = PURPLE_STATUS_AWAY;
+			break;
+		case MSIM_STATUS_CODE_IDLE:
+			/* Treat idle as an available status. */
+			purple_status_code = PURPLE_STATUS_AVAILABLE;
+			break;
+		default:
+			purple_debug_info("msim", "msim_incoming_status for %s, unknown status code %d, treating as available\n",
+						username, status_code);
+			purple_status_code = PURPLE_STATUS_AVAILABLE;
+			unrecognized_msg = g_strdup_printf("msim_incoming_status, unrecognized status code: %d\n",
+					status_code);
+			msim_unrecognized(session, NULL, unrecognized_msg);
+			g_free(unrecognized_msg);
+	}
+	purple_prpl_got_user_status(session->account, username, purple_primitive_get_id_from_type(purple_status_code), NULL);
+	if (status_code == MSIM_STATUS_CODE_IDLE) {
+		purple_debug_info("msim", "msim_status: got idle: %s\n", username);
+		purple_prpl_got_user_idle(session->account, username, TRUE, time(NULL));
+	} else {
+		/* All other statuses indicate going back to non-idle. */
+		purple_prpl_got_user_idle(session->account, username, FALSE, time(NULL));
+	}
+#ifdef MSIM_SEND_CLIENT_VERSION
+	if (status_code == MSIM_STATUS_CODE_ONLINE) {
+		/* Secretly whisper to unofficial clients our own version as they come online */
+		msim_send_unofficial_client(session, username);
+	}
+#endif
+	if (status_code != MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN) {
+		/* Get information when they come online.
+		 * TODO: periodically refresh?
+		 */
+		purple_debug_info("msim_incoming_status", "%s came online, looking up\n", username);
+		msim_lookup_user(session, username, NULL, NULL);
+	}
+	g_free(username);
+	msim_msg_list_free(list);
+	return TRUE;
+}
+/**
+* Handle an incoming instant message.
+*
+* @param session The session
+* @param msg Message from the server, containing 'f' (userid from) and 'msg'.
+*               Should also contain username in _username from preprocessing.
+*
+* @return TRUE if successful.
+*/
+static gboolean
+msim_incoming_im(MsimSession *session, MsimMessage *msg)
+{
+	gchar *username, *msg_msim_markup, *msg_purple_markup;
+	gchar *userid;
+	time_t time_received;
+	PurpleConversation *conv;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+	username = msim_msg_get_string(msg, "_username");
+	/* I know this isn't really a string... but we need it to be one for
+	 * purple_find_conversation_with_account(). */
+	userid = msim_msg_get_string(msg, "f");
+	g_return_val_if_fail(username != NULL, FALSE);
+	purple_debug_info("msim_incoming_im", "UserID is %s", userid);
+	if (msim_is_userid(username)) {
+		purple_debug_info("msim", "Ignoring message from spambot (%s) on account %s\n",
+				username, purple_account_get_username(session->account));
+		g_free(username);
+		return FALSE;
+	}
+	/* See if a conversation with their UID already exists...*/
+	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, userid, session->account);
+	if (conv) {
+		/* Since the conversation exists... We need to normalize it */
+		purple_conversation_set_name(conv, username);
+	}
+	msg_msim_markup = msim_msg_get_string(msg, "msg");
+	g_return_val_if_fail(msg_msim_markup != NULL, FALSE);
+	msg_purple_markup = msim_markup_to_html(session, msg_msim_markup);
+	g_free(msg_msim_markup);
+	time_received = msim_msg_get_integer(msg, "date");
+	if (!time_received) {
+		purple_debug_info("msim_incoming_im", "date in message not set.\n");
+		time_received = time(NULL);
+	}
+	serv_got_im(session->gc, username, msg_purple_markup, PURPLE_MESSAGE_RECV, time_received);
+	g_free(username);
+	g_free(msg_purple_markup);
+	return TRUE;
+}
+/**
+* Handle an incoming action message.
+*
+* @param session
+* @param msg
+*
+* @return TRUE if successful.
+*/
+static gboolean
+msim_incoming_action(MsimSession *session, MsimMessage *msg)
+{
+	gchar *msg_text, *username;
+	gboolean rc;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+	msg_text = msim_msg_get_string(msg, "msg");
+	g_return_val_if_fail(msg_text != NULL, FALSE);
+	username = msim_msg_get_string(msg, "_username");
+	g_return_val_if_fail(username != NULL, FALSE);
+	purple_debug_info("msim", "msim_incoming_action: action <%s> from <%s>\n",
+			msg_text, username);
+	if (g_str_equal(msg_text, "%typing%")) {
+		serv_got_typing(session->gc, username, 0, PURPLE_TYPING);
+		rc = TRUE;
+	} else if (g_str_equal(msg_text, "%stoptyping%")) {
+		serv_got_typing_stopped(session->gc, username);
+		rc = TRUE;
+	} else if (strstr(msg_text, "!!!ZAP_SEND!!!=RTE_BTN_ZAPS_")) {
+		rc = msim_incoming_zap(session, msg);
+	} else if (strstr(msg_text, "!!!GroupCount=")) {
+		/* TODO: support group chats. I think the number in msg_text has
+		 * something to do with the 'gid' field. */
+		purple_debug_info("msim", "msim_incoming_action: TODO: implement #4691, group chats: %s\n", msg_text);
+		rc = TRUE;
+	} else if (strstr(msg_text, "!!!Offline=")) {
+		/* TODO: support group chats. This one might mean a user
+		 * went offline or exited the chat. */
+		purple_debug_info("msim", "msim_incoming_action: TODO: implement #4691, group chats: %s\n", msg_text);
+		rc = TRUE;
+	} else if (msim_msg_get_integer(msg, "aid") != 0) {
+		purple_debug_info("msim", "TODO: implement #4691, group chat from %d on %d: %s\n",
+				msim_msg_get_integer(msg, "aid"),
+				msim_msg_get_integer(msg, "f"),
+				msg_text);
+		rc = TRUE;
+	} else {
+		msim_unrecognized(session, msg,
+				"got to msim_incoming_action but unrecognized value for 'msg'");
+		rc = FALSE;
+	}
+	g_free(msg_text);
+	g_free(username);
+	return rc;
+}
+/**
+* Process an incoming media (message background?) message.
+*/
+static gboolean
+msim_incoming_media(MsimSession *session, MsimMessage *msg)
+{
+	gchar *username, *text;
+	username = msim_msg_get_string(msg, "_username");
+	text = msim_msg_get_string(msg, "msg");
+	g_return_val_if_fail(username != NULL, FALSE);
+	g_return_val_if_fail(text != NULL, FALSE);
+	purple_debug_info("msim", "msim_incoming_media: from %s, got msg=%s\n", username, text);
+	/* Media messages are sent when the user opens a window to someone.
+	 * Tell libpurple they started typing and stopped typing, to inform the Psychic
+	 * Mode plugin so it too can open a window to the user. */
+	serv_got_typing(session->gc, username, 0, PURPLE_TYPING);
+	serv_got_typing_stopped(session->gc, username);
+	g_free(username);
+	return TRUE;
+}
+/**
+* Process an incoming "unofficial client" message. The plugin for
+* Miranda IM sends this message with the plugin information.
+*/
+static gboolean
+msim_incoming_unofficial_client(MsimSession *session, MsimMessage *msg)
+{
+	MsimUser *user;
+	gchar *username, *client_info;
+	username = msim_msg_get_string(msg, "_username");
+	client_info = msim_msg_get_string(msg, "msg");
+	g_return_val_if_fail(username != NULL, FALSE);
+	g_return_val_if_fail(client_info != NULL, FALSE);
+	purple_debug_info("msim", "msim_incoming_unofficial_client: %s is using client %s\n",
+		username, client_info);
+	user = msim_find_user(session, username);
+	g_return_val_if_fail(user != NULL, FALSE);
+	if (user->client_info) {
+		g_free(user->client_info);
+	}
+	user->client_info = client_info;
+	g_free(username);
+	/* Do not free client_info - the MsimUser now owns it. */
+	return TRUE;
+}
+/**
+* Handle an incoming buddy message.
+*/
 static gboolean
 msim_incoming_bm(MsimSession *session, MsimMessage *msg)
 {
 	guint bm;
 		case MSIM_BM_MEDIA:
 			return msim_incoming_media(session, msg);
 		case MSIM_BM_UNOFFICIAL_CLIENT:
 			return msim_incoming_unofficial_client(session, msg);
 		default:
 			/* Not really an IM, but show it for informational
 			 * purposes during development. */
 			return msim_incoming_im(session, msg);
 	}
 }
 /**
-* Handle an incoming instant message.
+* Process the initial server information from the server.
-*
+*/
-* @param session The session
+static gboolean
-* @param msg Message from the server, containing 'f' (userid from) and 'msg'.
+msim_process_server_info(MsimSession *session, MsimMessage *msg)
-*               Should also contain username in _username from preprocessing.
+{
+	MsimMessage *body;
+	body = msim_msg_get_dictionary(msg, "body");
+	g_return_val_if_fail(body != NULL, FALSE);
+	/* Example body:
+AdUnitRefreshInterval=10.
+AlertPollInterval=360.
+AllowChatRoomEmoticonSharing=False.
+ChatRoomUserIDs=78744676;163733130;1300326231;123521495;142663391.
+CurClientVersion=673.
+EnableIMBrowse=True.
+EnableIMStuffAvatars=False.
+EnableIMStuffZaps=False.
+MaxAddAllFriends=100.
+MaxContacts=1000.
+MinClientVersion=594.
+MySpaceIM_ENGLISH=78744676.
+MySpaceNowTimer=720.
+PersistenceDataTimeout=900.
+UseWebChallenge=1.
+WebTicketGoHome=False
+	Anything useful? TODO: use what is useful, and use it.
+*/
+	purple_debug_info("msim_process_server_info",
+			"maximum contacts: %d\n",
+			msim_msg_get_integer(body, "MaxContacts"));
+	session->server_info = body;
+	/* session->server_info freed in msim_session_destroy */
+	return TRUE;
+}
+/**
+* Process a web challenge, used to login to the web site.
+*/
+static gboolean
+msim_web_challenge(MsimSession *session, MsimMessage *msg)
+{
+	/* TODO: web challenge, store token. #2659. */
+	return FALSE;
+}
+/**
+* Process a persistance message reply from the server.
+*
+* @param session
+* @param msg Message reply from server.
 *
 * @return TRUE if successful.
-*/
+*
-static gboolean
+* msim_lookup_user sets callback for here
-msim_incoming_im(MsimSession *session, MsimMessage *msg)
+*/
-{
+static gboolean
-	gchar *username, *msg_msim_markup, *msg_purple_markup;
+msim_process_reply(MsimSession *session, MsimMessage *msg)
-	gchar *userid;
+{
-	time_t time_received;
+	MSIM_USER_LOOKUP_CB cb;
-	PurpleConversation *conv;
+	gpointer data;
+	guint rid, cmd, dsn, lid;
 	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
 	g_return_val_if_fail(msg != NULL, FALSE);
-	username = msim_msg_get_string(msg, "_username");
+	msim_store_user_info(session, msg, NULL);
-	/* I know this isn't really a string... but we need it to be one for
-	 * purple_find_conversation_with_account(). */
+	rid = msim_msg_get_integer(msg, "rid");
-	userid = msim_msg_get_string(msg, "f");
+	cmd = msim_msg_get_integer(msg, "cmd");
-	g_return_val_if_fail(username != NULL, FALSE);
+	dsn = msim_msg_get_integer(msg, "dsn");
+	lid = msim_msg_get_integer(msg, "lid");
-	purple_debug_info("msim_incoming_im", "UserID is %s", userid);
+	/* Unsolicited messages */
-	if (msim_is_userid(username)) {
+	if (cmd == (MSIM_CMD_BIT_REPLY | MSIM_CMD_GET)) {
-		purple_debug_info("msim", "Ignoring message from spambot (%s) on account %s\n",
+		if (dsn == MG_SERVER_INFO_DSN && lid == MG_SERVER_INFO_LID) {
-				username, purple_account_get_username(session->account));
+			return msim_process_server_info(session, msg);
-		g_free(username);
+		} else if (dsn == MG_WEB_CHALLENGE_DSN && lid == MG_WEB_CHALLENGE_LID) {
-		return FALSE;
+			return msim_web_challenge(session, msg);
-	}
+		}
+	}
-	/* See if a conversation with their UID already exists...*/
-	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, userid, session->account);
+	/* If a callback is registered for this userid lookup, call it. */
-	if (conv) {
+	cb = g_hash_table_lookup(session->user_lookup_cb, GUINT_TO_POINTER(rid));
-		/* Since the conversation exists... We need to normalize it */
+	data = g_hash_table_lookup(session->user_lookup_cb_data, GUINT_TO_POINTER(rid));
-		purple_conversation_set_name(conv, username);
-	}
+	if (cb) {
+		purple_debug_info("msim", "msim_process_reply: calling callback now\n");
-	msg_msim_markup = msim_msg_get_string(msg, "msg");
+		msim_msg_dump("for msg=%s\n", msg);
-	g_return_val_if_fail(msg_msim_markup != NULL, FALSE);
+		/* Clone message, so that the callback 'cb' can use it (needs to free it also). */
+		cb(session, msim_msg_clone(msg), data);
-	msg_purple_markup = msim_markup_to_html(session, msg_msim_markup);
+		g_hash_table_remove(session->user_lookup_cb, GUINT_TO_POINTER(rid));
-	g_free(msg_msim_markup);
+		g_hash_table_remove(session->user_lookup_cb_data, GUINT_TO_POINTER(rid));
+	} else {
-	time_received = msim_msg_get_integer(msg, "date");
+		purple_debug_info("msim",
-	if (!time_received) {
+				"msim_process_reply: no callback for rid %d\n", rid);
-		purple_debug_info("msim_incoming_im", "date in message not set.\n");
+	}
-		time_received = time(NULL);
-	}
-	serv_got_im(session->gc, username, msg_purple_markup, PURPLE_MESSAGE_RECV, time_received);
-	g_free(username);
-	g_free(msg_purple_markup);
 	return TRUE;
 }
 /**
-* Process unrecognized information.
+* Handle an error from the server.
 *
 * @param session
-* @param msg An MsimMessage that was unrecognized, or NULL.
+* @param msg The message.
-* @param note Information on what was unrecognized, or NULL.
+*
-*/
+* @return TRUE if successfully reported error.
-void
+*/
-msim_unrecognized(MsimSession *session, MsimMessage *msg, gchar *note)
+static gboolean
-{
+msim_error(MsimSession *session, MsimMessage *msg)
-	/* TODO: Some more context, outwardly equivalent to a backtrace,
+{
-	 * for helping figure out what this msg is for. What was going on?
+	gchar *errmsg, *full_errmsg;
-	 * But not too much information so that a user
+	guint err;
-	 * posting this dump reveals confidential information.
-	 */
-	/* TODO: dump unknown msgs to file, so user can send them to me
-	 * if they wish, to help add support for new messages (inspired
-	 * by Alexandr Shutko, who maintains OSCAR protocol documentation).
-	 *
-	 * Filed enhancement ticket for libpurple as #4688.
-	 */
-	purple_debug_info("msim", "Unrecognized data on account for %s\n",
-			(session && session->account && session->account->username) ?
-			session->account->username : "(NULL)");
-	if (note) {
-		purple_debug_info("msim", "(Note: %s)\n", note);
-	}
-	if (msg) {
-		msim_msg_dump("Unrecognized message dump: %s\n", msg);
-	}
-}
-/**
-* Handle an incoming action message.
-*
-* @param session
-* @param msg
-*
-* @return TRUE if successful.
-*
-*/
-static gboolean
-msim_incoming_action(MsimSession *session, MsimMessage *msg)
-{
-	gchar *msg_text, *username;
-	gboolean rc;
 	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
 	g_return_val_if_fail(msg != NULL, FALSE);
-	msg_text = msim_msg_get_string(msg, "msg");
+	err = msim_msg_get_integer(msg, "err");
-	g_return_val_if_fail(msg_text != NULL, FALSE);
+	errmsg = msim_msg_get_string(msg, "errmsg");
-	username = msim_msg_get_string(msg, "_username");
+	full_errmsg = g_strdup_printf(_("Protocol error, code %d: %s"), err,
-	g_return_val_if_fail(username != NULL, FALSE);
+			errmsg ? errmsg : "no 'errmsg' given");
-	purple_debug_info("msim", "msim_incoming_action: action <%s> from <%s>\n",
+	g_free(errmsg);
-			msg_text, username);
+	purple_debug_info("msim", "msim_error (sesskey=%d): %s\n",
-	if (g_str_equal(msg_text, "%typing%")) {
+			session->sesskey, full_errmsg);
-		serv_got_typing(session->gc, username, 0, PURPLE_TYPING);
-		rc = TRUE;
+	/* Destroy session if fatal. */
-	} else if (g_str_equal(msg_text, "%stoptyping%")) {
+	if (msim_msg_get(msg, "fatal")) {
-		serv_got_typing_stopped(session->gc, username);
+		PurpleConnectionError reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
-		rc = TRUE;
+		purple_debug_info("msim", "fatal error, closing\n");
-	} else if (strstr(msg_text, "!!!ZAP_SEND!!!=RTE_BTN_ZAPS_")) {
-		rc = msim_incoming_zap(session, msg);
+		switch (err) {
-	} else if (strstr(msg_text, "!!!GroupCount=")) {
+			case MSIM_ERROR_INCORRECT_PASSWORD: /* Incorrect password */
-		/* TODO: support group chats. I think the number in msg_text has
+				reason = PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED;
-		 * something to do with the 'gid' field. */
+				if (!purple_account_get_remember_password(session->account))
-		purple_debug_info("msim", "msim_incoming_action: TODO: implement #4691, group chats: %s\n", msg_text);
+					purple_account_set_password(session->account, NULL);
+#ifdef MSIM_MAX_PASSWORD_LENGTH
-		rc = TRUE;
+				if (session->account->password && (strlen(session->account->password) > MSIM_MAX_PASSWORD_LENGTH)) {
-	} else if (strstr(msg_text, "!!!Offline=")) {
+					gchar *suggestion;
-		/* TODO: support group chats. This one might mean a user
-		 * went offline or exited the chat. */
+					suggestion = g_strdup_printf(_("%s Your password is "
-		purple_debug_info("msim", "msim_incoming_action: TODO: implement #4691, group chats: %s\n", msg_text);
+							"%d characters, greater than the "
+							"expected maximum length of %d for "
-		rc = TRUE;
+							"MySpaceIM. Please shorten your "
-	} else if (msim_msg_get_integer(msg, "aid") != 0) {
+							"password at http://profileedit.myspace.com/index.cfm?fuseaction=accountSettings.changePassword and try again."),
-		purple_debug_info("msim", "TODO: implement #4691, group chat from %d on %d: %s\n",
+							full_errmsg, (int)
-				msim_msg_get_integer(msg, "aid"),
+							strlen(session->account->password),
-				msim_msg_get_integer(msg, "f"),
+							MSIM_MAX_PASSWORD_LENGTH);
-				msg_text);
+					/* Replace full_errmsg. */
-		rc = TRUE;
+					g_free(full_errmsg);
+					full_errmsg = suggestion;
+				}
+#endif
+				break;
+			case MSIM_ERROR_LOGGED_IN_ELSEWHERE: /* Logged in elsewhere */
+				reason = PURPLE_CONNECTION_ERROR_NAME_IN_USE;
+				if (!purple_account_get_remember_password(session->account))
+					purple_account_set_password(session->account, NULL);
+				break;
+		}
+		purple_connection_error_reason (session->gc, reason, full_errmsg);
 	} else {
-		msim_unrecognized(session, msg,
+		purple_notify_error(session->account, _("MySpaceIM Error"), full_errmsg, NULL);
-				"got to msim_incoming_action but unrecognized value for 'msg'");
+	}
-		rc = FALSE;
-	}
+	g_free(full_errmsg);
-	g_free(msg_text);
-	g_free(username);
-	return rc;
-}
-/* Process an incoming media (message background?) message. */
-static gboolean
-msim_incoming_media(MsimSession *session, MsimMessage *msg)
-{
-	gchar *username, *text;
-	username = msim_msg_get_string(msg, "_username");
-	text = msim_msg_get_string(msg, "msg");
-	g_return_val_if_fail(username != NULL, FALSE);
-	g_return_val_if_fail(text != NULL, FALSE);
-	purple_debug_info("msim", "msim_incoming_media: from %s, got msg=%s\n", username, text);
-	/* Media messages are sent when the user opens a window to someone.
-	 * Tell libpurple they started typing and stopped typing, to inform the Psychic
-	 * Mode plugin so it too can open a window to the user. */
-	serv_got_typing(session->gc, username, 0, PURPLE_TYPING);
-	serv_got_typing_stopped(session->gc, username);
-	g_free(username);
 	return TRUE;
 }
-/* Process an incoming "unofficial client" message. The plugin for
+/**
-* Miranda IM sends this message with the plugin information. */
+* Process a message.
-static gboolean
-msim_incoming_unofficial_client(MsimSession *session, MsimMessage *msg)
-{
-	MsimUser *user;
-	gchar *username, *client_info;
-	username = msim_msg_get_string(msg, "_username");
-	client_info = msim_msg_get_string(msg, "msg");
-	g_return_val_if_fail(username != NULL, FALSE);
-	g_return_val_if_fail(client_info != NULL, FALSE);
-	purple_debug_info("msim", "msim_incoming_unofficial_client: %s is using client %s\n",
-		username, client_info);
-	user = msim_find_user(session, username);
-	g_return_val_if_fail(user != NULL, FALSE);
-	if (user->client_info) {
-		g_free(user->client_info);
-	}
-	user->client_info = client_info;
-	g_free(username);
-	/* Do not free client_info - the MsimUser now owns it. */
-	return TRUE;
-}
-#ifdef MSIM_SEND_CLIENT_VERSION
-/** Send our client version to another unofficial client that understands it. */
-static gboolean
-msim_send_unofficial_client(MsimSession *session, gchar *username)
-{
-	gchar *our_info;
-	gboolean ret;
-	our_info = g_strdup_printf("Libpurple %d.%d.%d - msimprpl %s",
-			PURPLE_MAJOR_VERSION,
-			PURPLE_MINOR_VERSION,
-			PURPLE_MICRO_VERSION,
-			MSIM_PRPL_VERSION_STRING);
-	ret = msim_send_bm(session, username, our_info, MSIM_BM_UNOFFICIAL_CLIENT);
-	return ret;
-}
-#endif
-/**
-* Handle when our user starts or stops typing to another user.
-*
-* @param gc
-* @param name The buddy name to which our user is typing to
-* @param state PURPLE_TYPING, PURPLE_TYPED, PURPLE_NOT_TYPING
-*
-* @return 0
-*/
-unsigned int
-msim_send_typing(PurpleConnection *gc, const gchar *name,
-		PurpleTypingState state)
-{
-	const gchar *typing_str;
-	MsimSession *session;
-	g_return_val_if_fail(gc != NULL, 0);
-	g_return_val_if_fail(name != NULL, 0);
-	session = (MsimSession *)gc->proto_data;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), 0);
-	switch (state) {
-		case PURPLE_TYPING:
-			typing_str = "%typing%";
-			break;
-		case PURPLE_TYPED:
-		case PURPLE_NOT_TYPING:
-		default:
-			typing_str = "%stoptyping%";
-			break;
-	}
-	purple_debug_info("msim", "msim_send_typing(%s): %d (%s)\n", name, state, typing_str);
-	msim_send_bm(session, name, typing_str, MSIM_BM_ACTION);
-	return 0;
-}
-/** Callback for msim_get_info(), for when user info is received. */
-static void
-msim_get_info_cb(MsimSession *session, MsimMessage *user_info_msg,
-		gpointer data)
-{
-	MsimMessage *msg;
-	gchar *username;
-	PurpleNotifyUserInfo *user_info;
-	MsimUser *user;
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	/* Get user{name,id} from msim_get_info, passed as an MsimMessage for
-	   orthogonality. */
-	msg = (MsimMessage *)data;
-	g_return_if_fail(msg != NULL);
-	username = msim_msg_get_string(msg, "user");
-	if (!username) {
-		purple_debug_info("msim", "msim_get_info_cb: no 'user' in msg\n");
-		return;
-	}
-	msim_msg_free(msg);
-	purple_debug_info("msim", "msim_get_info_cb: got for user: %s\n", username);
-	user = msim_find_user(session, username);
-	if (!user) {
-		/* User isn't on blist, create a temporary user to store info. */
-		user = g_new0(MsimUser, 1);
-		user->temporary_user = TRUE;
-	}
-	/* Update user structure with new information */
-	msim_store_user_info(session, user_info_msg, user);
-	user_info = purple_notify_user_info_new();
-	/* Append data from MsimUser to PurpleNotifyUserInfo for display, full */
-	msim_append_user_info(session, user_info, user, TRUE);
-	purple_notify_userinfo(session->gc, username, user_info, NULL, NULL);
-	purple_debug_info("msim", "msim_get_info_cb: username=%s\n", username);
-	purple_notify_user_info_destroy(user_info);
-	if (user->temporary_user) {
-		g_free(user->client_info);
-		g_free(user->gender);
-		g_free(user->location);
-		g_free(user->headline);
-		g_free(user->display_name);
-		g_free(user->username);
-		g_free(user->image_url);
-		g_free(user);
-	}
-	g_free(username);
-}
-/** Retrieve a user's profile.
-* @param username Username, user ID, or email address to lookup.
-*/
-void
-msim_get_info(PurpleConnection *gc, const gchar *username)
-{
-	MsimSession *session;
-	MsimUser *user;
-	gchar *user_to_lookup;
-	MsimMessage *user_msg;
-	g_return_if_fail(gc != NULL);
-	g_return_if_fail(username != NULL);
-	session = (MsimSession *)gc->proto_data;
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	/* Obtain uid of buddy. */
-	user = msim_find_user(session, username);
-	/* If is on buddy list, lookup by uid since it is faster. */
-	if (user && user->id) {
-		user_to_lookup = g_strdup_printf("%d", user->id);
-	} else {
-		/* Looking up buddy not on blist. Lookup by whatever user entered. */
-		user_to_lookup = g_strdup(username);
-	}
-	/* Pass the username to msim_get_info_cb(), because since we lookup
-	 * by userid, the userinfo message will only contain the uid (not
-	 * the username) but it would be useful to display the username too.
-	 */
-	user_msg = msim_msg_new(
-			"user", MSIM_TYPE_STRING, g_strdup(username),
-			NULL);
-	purple_debug_info("msim", "msim_get_info, setting up lookup, user=%s\n", username);
-	msim_lookup_user(session, user_to_lookup, msim_get_info_cb, user_msg);
-	g_free(user_to_lookup);
-}
-/** Set your status - callback for when user manually sets it.  */
-void
-msim_set_status(PurpleAccount *account, PurpleStatus *status)
-{
-	PurpleStatusType *type;
-	PurplePresence *pres;
-	MsimSession *session;
-	guint status_code;
-	const gchar *message;
-	gchar *stripped;
-	gchar *unrecognized_msg;
-	session = (MsimSession *)account->gc->proto_data;
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	type = purple_status_get_type(status);
-	pres = purple_status_get_presence(status);
-	switch (purple_status_type_get_primitive(type)) {
-		case PURPLE_STATUS_AVAILABLE:
-			purple_debug_info("msim", "msim_set_status: available (%d->%d)\n", PURPLE_STATUS_AVAILABLE,
-					MSIM_STATUS_CODE_ONLINE);
-			status_code = MSIM_STATUS_CODE_ONLINE;
-			break;
-		case PURPLE_STATUS_INVISIBLE:
-			purple_debug_info("msim", "msim_set_status: invisible (%d->%d)\n", PURPLE_STATUS_INVISIBLE,
-					MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN);
-			status_code = MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN;
-			break;
-		case PURPLE_STATUS_AWAY:
-			purple_debug_info("msim", "msim_set_status: away (%d->%d)\n", PURPLE_STATUS_AWAY,
-					MSIM_STATUS_CODE_AWAY);
-			status_code = MSIM_STATUS_CODE_AWAY;
-			break;
-		default:
-			purple_debug_info("msim", "msim_set_status: unknown "
-					"status interpreting as online");
-			status_code = MSIM_STATUS_CODE_ONLINE;
-			unrecognized_msg = g_strdup_printf("msim_set_status, unrecognized status type: %d\n",
-					purple_status_type_get_primitive(type));
-			msim_unrecognized(session, NULL, unrecognized_msg);
-			g_free(unrecognized_msg);
-			break;
-	}
-	message = purple_status_get_attr_string(status, "message");
-	/* Status strings are plain text. */
-	if (message != NULL)
-		stripped = purple_markup_strip_html(message);
-	else
-		stripped = g_strdup("");
-	msim_set_status_code(session, status_code, stripped);
-	/* If we should be idle, set that status. Time is irrelevant here. */
-	if (purple_presence_is_idle(pres) && status_code != MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN)
-		msim_set_idle(account->gc, 1);
-}
-/** Go idle. */
-void
-msim_set_idle(PurpleConnection *gc, int time)
-{
-	MsimSession *session;
-	PurpleStatus *status;
-	g_return_if_fail(gc != NULL);
-	session = (MsimSession *)gc->proto_data;
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	status = purple_account_get_active_status(session->account);
-	if (time == 0) {
-		/* Going back from idle. In msim, idle is mutually exclusive
-		 * from the other states (you can only be away or idle, but not
-		 * both, for example), so by going non-idle I go back to what
-		 * libpurple says I should be.
-		 */
-		msim_set_status(session->account, status);
-	} else {
-		const gchar *message;
-		gchar *stripped;
-		/* Set the idle message to the status message from the real
-		 * current status.
-		 */
-		message = purple_status_get_attr_string(status, "message");
-		if (message != NULL)
-			stripped = purple_markup_strip_html(message);
-		else
-			stripped = g_strdup("");
-		/* msim doesn't support idle time, so just go idle */
-		msim_set_status_code(session, MSIM_STATUS_CODE_IDLE, stripped);
-	}
-}
-/** Set status using an MSIM_STATUS_CODE_* value.
-* @param status_code An MSIM_STATUS_CODE_* value.
-* @param statstring Status string, must be a dynamic string (will be freed by msim_send).
-*/
-static void
-msim_set_status_code(MsimSession *session, guint status_code, gchar *statstring)
-{
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	g_return_if_fail(statstring != NULL);
-	purple_debug_info("msim", "msim_set_status_code: going to set status to code=%d,str=%s\n",
-			status_code, statstring);
-	if (!msim_send(session,
-			"status", MSIM_TYPE_INTEGER, status_code,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"statstring", MSIM_TYPE_STRING, statstring,
-			"locstring", MSIM_TYPE_STRING, g_strdup(""),
-			NULL))
-	{
-		purple_debug_info("msim", "msim_set_status: failed to set status\n");
-	}
-}
-/** After a uid is resolved to username, tag it with the username and submit for processing.
-*
-* @param session
-* @param userinfo Response messsage to resolving request.
-* @param data MsimMessage *, the message to attach information to.
-*/
-static void
-msim_incoming_resolved(MsimSession *session, MsimMessage *userinfo,
-		gpointer data)
-{
-	gchar *username;
-	MsimMessage *msg, *body;
-	g_return_if_fail(MSIM_SESSION_VALID(session));
-	g_return_if_fail(userinfo != NULL);
-	body = msim_msg_get_dictionary(userinfo, "body");
-	g_return_if_fail(body != NULL);
-	username = msim_msg_get_string(body, "UserName");
-	g_return_if_fail(username != NULL);
-	/* Note: username will be owned by 'msg' below. */
-	msg = (MsimMessage *)data;
-	g_return_if_fail(msg != NULL);
-	/* TODO: more elegant solution than below. attach whole message? */
-	/* Special elements name beginning with '_', we'll use internally within the
-	 * program (did not come directly from the wire). */
-	msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, username); /* This makes 'msg' the owner of 'username' */
-	/* TODO: attach more useful information, like ImageURL */
-	msim_process(session, msg);
-	/* TODO: Free copy cloned from  msim_preprocess_incoming(). */
-	/* msim_msg_free(msg); */
-	msim_msg_free(body);
-}
-/* Lookup a username by userid, from buddy list.
-*
-* @param wanted_uid
-*
-* @return Username of wanted_uid, if on blist, or NULL.
-* 	This is a static string, so don't free it. Copy it if needed.
-*
-*/
-static const gchar *
-msim_uid2username_from_blist(PurpleAccount *account, guint wanted_uid)
-{
-	GSList *buddies, *cur;
-	const gchar *ret;
-	buddies = purple_find_buddies(account, NULL);
-	if (!buddies)
-	{
-		purple_debug_info("msim", "msim_uid2username_from_blist: no buddies?\n");
-		return NULL;
-	}
-	ret = NULL;
-	for (cur = buddies; cur != NULL; cur = g_slist_next(cur))
-	{
-		PurpleBuddy *buddy;
-		guint uid;
-		const gchar *name;
-		/* See finch/gnthistory.c */
-		buddy = cur->data;
-		uid = purple_blist_node_get_int(&buddy->node, "UserID");
-		name = purple_buddy_get_name(buddy);
-		if (uid == wanted_uid)
-		{
-			ret = name;
-			break;
-		}
-	}
-	g_slist_free(buddies);
-	return ret;
-}
-/** Preprocess incoming messages, resolving as needed, calling msim_process() when ready to process.
-*
-* @param session
-* @param msg MsimMessage *, freed by caller.
-*/
-static gboolean
-msim_preprocess_incoming(MsimSession *session, MsimMessage *msg)
-{
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	g_return_val_if_fail(msg != NULL, FALSE);
-	if (msim_msg_get(msg, "bm") && msim_msg_get(msg, "f")) {
-		guint uid;
-		const gchar *username;
-		/* 'f' = userid message is from, in buddy messages */
-		uid = msim_msg_get_integer(msg, "f");
-		username = msim_uid2username_from_blist(session->account, uid);
-		if (username) {
-			/* Know username already, use it. */
-			purple_debug_info("msim", "msim_preprocess_incoming: tagging with _username=%s\n",
-					username);
-			msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, g_strdup(username));
-			return msim_process(session, msg);
-		} else {
-			gchar *from;
-			/* Send lookup request. */
-			/* XXX: where is msim_msg_get_string() freed? make _strdup and _nonstrdup. */
-			purple_debug_info("msim", "msim_incoming: sending lookup, setting up callback\n");
-			from = msim_msg_get_string(msg, "f");
-			msim_lookup_user(session, from, msim_incoming_resolved, msim_msg_clone(msg));
-			g_free(from);
-			/* indeterminate */
-			return TRUE;
-		}
-	} else {
-		/* Nothing to resolve - send directly to processing. */
-		return msim_process(session, msg);
-	}
-}
-#ifdef MSIM_USE_KEEPALIVE
-/** Check if the connection is still alive, based on last communication. */
-static gboolean
-msim_check_alive(gpointer data)
-{
-	MsimSession *session;
-	time_t delta;
-	session = (MsimSession *)data;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	delta = time(NULL) - session->last_comm;
-	/* purple_debug_info("msim", "msim_check_alive: delta=%d\n", delta); */
-	if (delta >= MSIM_KEEPALIVE_INTERVAL) {
-		purple_debug_info("msim",
-				"msim_check_alive: %zu > interval of %d, presumed dead\n",
-				delta, MSIM_KEEPALIVE_INTERVAL);
-		purple_connection_error_reason(session->gc,
-				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
-				_("Lost connection with server"));
-		return FALSE;
-	}
-	return TRUE;
-}
-#endif
-/** Handle mail reply checks. */
-static void
-msim_check_inbox_cb(MsimSession *session, MsimMessage *reply, gpointer data)
-{
-	MsimMessage *body;
-	guint old_inbox_status;
-	guint i, n;
-	const gchar *froms[5], *tos[5], *urls[5], *subjects[5];
-	/* Information for each new inbox message type. */
-	static struct
-	{
-		const gchar *key;
-		guint bit;
-		const gchar *url;
-		const gchar *text;
-	} message_types[] = {
-		{ "Mail", MSIM_INBOX_MAIL, "http://messaging.myspace.com/index.cfm?fuseaction=mail.inbox", NULL },
-		{ "BlogComment", MSIM_INBOX_BLOG_COMMENT, "http://blog.myspace.com/index.cfm?fuseaction=blog", NULL },
-		{ "ProfileComment", MSIM_INBOX_PROFILE_COMMENT, "http://home.myspace.com/index.cfm?fuseaction=user", NULL },
-		{ "FriendRequest", MSIM_INBOX_FRIEND_REQUEST, "http://messaging.myspace.com/index.cfm?fuseaction=mail.friendRequests", NULL },
-		{ "PictureComment", MSIM_INBOX_PICTURE_COMMENT, "http://home.myspace.com/index.cfm?fuseaction=user", NULL }
-	};
-	/* Can't write _()'d strings in array initializers. Workaround. */
-	message_types[0].text = _("New mail messages");
-	message_types[1].text = _("New blog comments");
-	message_types[2].text = _("New profile comments");
-	message_types[3].text = _("New friend requests!");
-	message_types[4].text = _("New picture comments");
-	g_return_if_fail(reply != NULL);
-	msim_msg_dump("msim_check_inbox_cb: reply=%s\n", reply);
-	body = msim_msg_get_dictionary(reply, "body");
-	if (body == NULL)
-		return;
-	old_inbox_status = session->inbox_status;
-	n = 0;
-	for (i = 0; i < sizeof(message_types) / sizeof(message_types[0]); ++i) {
-		const gchar *key;
-		guint bit;
-		key = message_types[i].key;
-		bit = message_types[i].bit;
-		if (msim_msg_get(body, key)) {
-			/* Notify only on when _changes_ from no mail -> has mail
-			 * (edge triggered) */
-			if (!(session->inbox_status & bit)) {
-				purple_debug_info("msim", "msim_check_inbox_cb: got %s, at %d\n",
-						key ? key : "(NULL)", n);
-				subjects[n] = message_types[i].text;
-				froms[n] = _("MySpace");
-				tos[n] = session->username;
-				/* TODO: append token, web challenge, so automatically logs in.
-				 * Would also need to free strings because they won't be static
-				 */
-				urls[n] = message_types[i].url;
-				++n;
-			} else {
-				purple_debug_info("msim",
-						"msim_check_inbox_cb: already notified of %s\n",
-						key ? key : "(NULL)");
-			}
-			session->inbox_status |= bit;
-		}
-	}
-	if (n) {
-		purple_debug_info("msim",
-				"msim_check_inbox_cb: notifying of %d\n", n);
-		/* TODO: free strings with callback _if_ change to dynamic (w/ token) */
-		purple_notify_emails(session->gc,         /* handle */
-				n,                        /* count */
-				TRUE,                     /* detailed */
-				subjects, froms, tos, urls,
-				NULL,                     /* PurpleNotifyCloseCallback cb */
-				NULL);                    /* gpointer user_data */
-	}
-	msim_msg_free(body);
-}
-/* Send request to check if there is new mail. */
-static gboolean
-msim_check_inbox(gpointer data)
-{
-	MsimSession *session;
-	session = (MsimSession *)data;
-	if (!MSIM_SESSION_VALID(session)) {
-		purple_debug_info("msim", "msim_check_inbox: session invalid, stopping the mail check.\n");
-		return FALSE;
-	}
-	purple_debug_info("msim", "msim_check_inbox: checking mail\n");
-	g_return_val_if_fail(msim_send(session,
-			"persist", MSIM_TYPE_INTEGER, 1,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_GET,
-			"dsn", MSIM_TYPE_INTEGER, MG_CHECK_MAIL_DSN,
-			"lid", MSIM_TYPE_INTEGER, MG_CHECK_MAIL_LID,
-			"uid", MSIM_TYPE_INTEGER, session->userid,
-			"rid", MSIM_TYPE_INTEGER,
-				msim_new_reply_callback(session, msim_check_inbox_cb, NULL),
-			"body", MSIM_TYPE_STRING, g_strdup(""),
-			NULL), TRUE);
-	/* Always return true, so that we keep checking for mail. */
-	return TRUE;
-}
-#ifdef MSIM_CHECK_NEWER_VERSION
-/** Callback for when a currentversion.txt has been downloaded. */
-static void
-msim_check_newer_version_cb(PurpleUtilFetchUrlData *url_data,
-		gpointer user_data,
-		const gchar *url_text,
-		gsize len,
-		const gchar *error_message)
-{
-	GKeyFile *keyfile;
-	GError *error;
-	GString *data;
-	gchar *newest_filever;
-	if (!url_text) {
-		purple_debug_info("msim_check_newer_version_cb",
-				"got error: %s\n", error_message);
-		return;
-	}
-	purple_debug_info("msim_check_newer_version_cb",
-			"url_text=%s\n", url_text ? url_text : "(NULL)");
-	/* Prepend [group] so that GKeyFile can parse it (requires a group). */
-	data = g_string_new(url_text);
-	purple_debug_info("msim", "data=%s\n", data->str
-			? data->str : "(NULL)");
-	data = g_string_prepend(data, "[group]\n");
-	purple_debug_info("msim", "data=%s\n", data->str
-			? data->str : "(NULL)");
-	/* url_text is variable=data\n...†*/
-	/* Check FILEVER, 1.0.716.0. 716 is build, MSIM_CLIENT_VERSION */
-	/* New (english) version can be downloaded from SETUPURL+SETUPFILE */
-	error = NULL;
-	keyfile = g_key_file_new();
-	/* Default list seperator is ;, but currentversion.txt doesn't have
-	 * these, so set to an unused character to avoid parsing problems. */
-	g_key_file_set_list_separator(keyfile, '\0');
-	g_key_file_load_from_data(keyfile, data->str, data->len,
-				G_KEY_FILE_NONE, &error);
-	g_string_free(data, TRUE);
-	if (error != NULL) {
-		purple_debug_info("msim_check_newer_version_cb",
-				"couldn't parse, error: %d %d %s\n",
-				error->domain, error->code, error->message);
-		g_error_free(error);
-		return;
-	}
-	gchar **ks;
-	guint n;
-	ks = g_key_file_get_keys(keyfile, "group", &n, NULL);
-	purple_debug_info("msim", "n=%d\n", n);
-	guint i;
-	for (i = 0; ks[i] != NULL; ++i)
-	{
-		purple_debug_info("msim", "%d=%s\n", i, ks[i]);
-	}
-	newest_filever = g_key_file_get_string(keyfile, "group",
-			"FILEVER", &error);
-	purple_debug_info("msim_check_newer_version_cb",
-			"newest filever: %s\n", newest_filever ?
-			newest_filever : "(NULL)");
-	if (error != NULL) {
-		purple_debug_info("msim_check_newer_version_cb",
-				"error: %d %d %s\n",
-				error->domain, error->code, error->message);
-		g_error_free(error);
-	}
-	g_key_file_free(keyfile);
-	exit(0);
-}
-#endif
-/** Called when the session key arrives to check whether the user
-* has a username, and set one if desired. */
-static gboolean
-msim_is_username_set(MsimSession *session, MsimMessage *msg)
-{
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	g_return_val_if_fail(msg != NULL, FALSE);
-	g_return_val_if_fail(session->gc != NULL, FALSE);
-	session->sesskey = msim_msg_get_integer(msg, "sesskey");
-	purple_debug_info("msim", "SESSKEY=<%d>\n", session->sesskey);
-	/* What is proof? Used to be uid, but now is 52 base64'd bytes... */
-	/* Comes with: proof,profileid,userid,uniquenick -- all same values
-	 * some of the time, but can vary. This is our own user ID. */
-	session->userid = msim_msg_get_integer(msg, "userid");
-	/* Save uid to account so this account can be looked up by uid. */
-	purple_account_set_int(session->account, "uid", session->userid);
-	/* Not sure what profileid is used for. */
-	if (msim_msg_get_integer(msg, "profileid") != session->userid) {
-		msim_unrecognized(session, msg,
-				"Profile ID didn't match user ID, don't know why");
-	}
-	/* We now know are our own username, only after we're logged in..
-	 * which is weird, but happens because you login with your email
-	 * address and not username. Will be freed in msim_session_destroy(). */
-	session->username = msim_msg_get_string(msg, "uniquenick");
-	/* If user lacks a username, help them get one. */
-	if (msim_msg_get_integer(msg, "uniquenick") == session->userid) {
-		purple_debug_info("msim_is_username_set", "no username is set\n");
-		purple_request_yes_no(session->gc,
-			_("MySpaceIM - No Username Set"),
-			_("You appear to have no MySpace username."),
-			_("Would you like to set one now? (Note: THIS CANNOT BE CHANGED!)"),
-			0,
-			session->account,
-			NULL,
-			NULL,
-			session->gc,
-			G_CALLBACK(msim_set_username_cb),
-			G_CALLBACK(msim_do_not_set_username_cb));
-		purple_debug_info("msim_is_username_set","'username not set' alert prompted\n");
-		return FALSE;
-	}
-	return TRUE;
-}
-/** Called after username is set, if necessary and we're open for business. */
-gboolean msim_we_are_logged_on(MsimSession *session)
-{
-	MsimMessage *body;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	/* The session is now set up, ready to be connected. This emits the
-	 * signedOn signal, so clients can now do anything with msimprpl, and
-	 * we're ready for it (session key, userid, username all setup). */
-	purple_connection_update_progress(session->gc, _("Connected"), 3, 4);
-	purple_connection_set_state(session->gc, PURPLE_CONNECTED);
-	/* Set display name to username (otherwise will show email address) */
-	purple_connection_set_display_name(session->gc, session->username);
-	body = msim_msg_new(
-			"UserID", MSIM_TYPE_INTEGER, session->userid,
-			NULL);
-	/* Request IM info about ourself. */
-	msim_send(session,
-			"persist", MSIM_TYPE_STRING, g_strdup("persist"),
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"dsn", MSIM_TYPE_INTEGER, MG_OWN_MYSPACE_INFO_DSN,
-			"uid", MSIM_TYPE_INTEGER, session->userid,
-			"lid", MSIM_TYPE_INTEGER, MG_OWN_MYSPACE_INFO_LID,
-			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-			"body", MSIM_TYPE_DICTIONARY, body,
-			NULL);
-	/* Request MySpace info about ourself. */
-	msim_send(session,
-			"persist", MSIM_TYPE_STRING, g_strdup("persist"),
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"dsn", MSIM_TYPE_INTEGER, MG_OWN_IM_INFO_DSN,
-			"uid", MSIM_TYPE_INTEGER, session->userid,
-			"lid", MSIM_TYPE_INTEGER, MG_OWN_IM_INFO_LID,
-			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-			"body", MSIM_TYPE_STRING, g_strdup(""),
-			NULL);
-	/* TODO: set options (persist cmd=514,dsn=1,lid=10) */
-	/* TODO: set blocklist */
-	/* Notify servers of our current status. */
-	purple_debug_info("msim", "msim_we_are_logged_on: notifying servers of status\n");
-	msim_set_status(session->account,
-			purple_account_get_active_status(session->account));
-	/* TODO: setinfo */
-	/*
-	body = msim_msg_new(
-		"TotalFriends", MSIM_TYPE_INTEGER, 666,
-		NULL);
-	msim_send(session,
-			"setinfo", MSIM_TYPE_BOOLEAN, TRUE,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"info", MSIM_TYPE_DICTIONARY, body,
-			NULL);
-			*/
-	/* Disable due to problems with timeouts. TODO: fix. */
-#ifdef MSIM_USE_KEEPALIVE
-	purple_timeout_add(MSIM_KEEPALIVE_INTERVAL_CHECK,
-			(GSourceFunc)msim_check_alive, session);
-#endif
-	/* Check mail if they want to. */
-	if (purple_account_get_check_mail(session->account)) {
-		session->inbox_handle = purple_timeout_add(MSIM_MAIL_INTERVAL_CHECK,
-				(GSourceFunc)msim_check_inbox, session);
-		msim_check_inbox(session);
-	}
-	msim_get_contact_list(session, MSIM_CONTACT_LIST_INITIAL_FRIENDS);
-	return TRUE;
-}
-/**
-* Process a message.
 *
 * @param session
 * @param msg A message from the server, ready for processing (possibly with resolved username information attached). Caller frees.
 *
 * @return TRUE if successful. FALSE if processing failed.
 */
 static gboolean
 msim_process(MsimSession *session, MsimMessage *msg)
 {
 	g_return_val_if_fail(session != NULL, FALSE);
 	g_return_val_if_fail(msg != NULL, FALSE);
 		msim_unrecognized(session, msg, "in msim_process");
 		return FALSE;
 	}
 }
-/** Process the initial server information from the server. */
+/**
+* After a uid is resolved to username, tag it with the username and submit for processing.
+*
+* @param session
+* @param userinfo Response messsage to resolving request.
+* @param data MsimMessage *, the message to attach information to.
+*/
+static void
+msim_incoming_resolved(MsimSession *session, MsimMessage *userinfo,
+		gpointer data)
+{
+	gchar *username;
+	MsimMessage *msg, *body;
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	g_return_if_fail(userinfo != NULL);
+	body = msim_msg_get_dictionary(userinfo, "body");
+	g_return_if_fail(body != NULL);
+	username = msim_msg_get_string(body, "UserName");
+	g_return_if_fail(username != NULL);
+	/* Note: username will be owned by 'msg' below. */
+	msg = (MsimMessage *)data;
+	g_return_if_fail(msg != NULL);
+	/* TODO: more elegant solution than below. attach whole message? */
+	/* Special elements name beginning with '_', we'll use internally within the
+	 * program (did not come directly from the wire). */
+	msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, username); /* This makes 'msg' the owner of 'username' */
+	/* TODO: attach more useful information, like ImageURL */
+	msim_process(session, msg);
+	/* TODO: Free copy cloned from  msim_preprocess_incoming(). */
+	/* msim_msg_free(msg); */
+	msim_msg_free(body);
+}
+/**
+* Preprocess incoming messages, resolving as needed, calling
+* msim_process() when ready to process.
+*
+* @param session
+* @param msg MsimMessage *, freed by caller.
+*/
 static gboolean
-msim_process_server_info(MsimSession *session, MsimMessage *msg)
+msim_preprocess_incoming(MsimSession *session, MsimMessage *msg)
 {
-	MsimMessage *body;
-	body = msim_msg_get_dictionary(msg, "body");
-	g_return_val_if_fail(body != NULL, FALSE);
-	/* Example body:
-AdUnitRefreshInterval=10.
-AlertPollInterval=360.
-AllowChatRoomEmoticonSharing=False.
-ChatRoomUserIDs=78744676;163733130;1300326231;123521495;142663391.
-CurClientVersion=673.
-EnableIMBrowse=True.
-EnableIMStuffAvatars=False.
-EnableIMStuffZaps=False.
-MaxAddAllFriends=100.
-MaxContacts=1000.
-MinClientVersion=594.
-MySpaceIM_ENGLISH=78744676.
-MySpaceNowTimer=720.
-PersistenceDataTimeout=900.
-UseWebChallenge=1.
-WebTicketGoHome=False
-	Anything useful? TODO: use what is useful, and use it.
-*/
-	purple_debug_info("msim_process_server_info",
-			"maximum contacts: %d\n",
-			msim_msg_get_integer(body, "MaxContacts"));
-	session->server_info = body;
-	/* session->server_info freed in msim_session_destroy */
-	return TRUE;
-}
-/** Process a web challenge, used to login to the web site. */
-static gboolean
-msim_web_challenge(MsimSession *session, MsimMessage *msg)
-{
-	/* TODO: web challenge, store token. #2659. */
-	return FALSE;
-}
-/**
-* Process a persistance message reply from the server.
-*
-* @param session
-* @param msg Message reply from server.
-*
-* @return TRUE if successful.
-*
-* msim_lookup_user sets callback for here
-*/
-static gboolean
-msim_process_reply(MsimSession *session, MsimMessage *msg)
-{
-	MSIM_USER_LOOKUP_CB cb;
-	gpointer data;
-	guint rid, cmd, dsn, lid;
 	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
 	g_return_val_if_fail(msg != NULL, FALSE);
-	msim_store_user_info(session, msg, NULL);
+	if (msim_msg_get(msg, "bm") && msim_msg_get(msg, "f")) {
+		guint uid;
-	rid = msim_msg_get_integer(msg, "rid");
+		const gchar *username;
-	cmd = msim_msg_get_integer(msg, "cmd");
-	dsn = msim_msg_get_integer(msg, "dsn");
+		/* 'f' = userid message is from, in buddy messages */
-	lid = msim_msg_get_integer(msg, "lid");
+		uid = msim_msg_get_integer(msg, "f");
-	/* Unsolicited messages */
+		username = msim_uid2username_from_blist(session->account, uid);
-	if (cmd == (MSIM_CMD_BIT_REPLY | MSIM_CMD_GET)) {
-		if (dsn == MG_SERVER_INFO_DSN && lid == MG_SERVER_INFO_LID) {
+		if (username) {
-			return msim_process_server_info(session, msg);
+			/* Know username already, use it. */
-		} else if (dsn == MG_WEB_CHALLENGE_DSN && lid == MG_WEB_CHALLENGE_LID) {
+			purple_debug_info("msim", "msim_preprocess_incoming: tagging with _username=%s\n",
-			return msim_web_challenge(session, msg);
+					username);
-		}
+			msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, g_strdup(username));
-	}
+			return msim_process(session, msg);
-	/* If a callback is registered for this userid lookup, call it. */
-	cb = g_hash_table_lookup(session->user_lookup_cb, GUINT_TO_POINTER(rid));
-	data = g_hash_table_lookup(session->user_lookup_cb_data, GUINT_TO_POINTER(rid));
-	if (cb) {
-		purple_debug_info("msim", "msim_process_reply: calling callback now\n");
-		msim_msg_dump("for msg=%s\n", msg);
-		/* Clone message, so that the callback 'cb' can use it (needs to free it also). */
-		cb(session, msim_msg_clone(msg), data);
-		g_hash_table_remove(session->user_lookup_cb, GUINT_TO_POINTER(rid));
-		g_hash_table_remove(session->user_lookup_cb_data, GUINT_TO_POINTER(rid));
-	} else {
-		purple_debug_info("msim",
-				"msim_process_reply: no callback for rid %d\n", rid);
-	}
-	return TRUE;
-}
-/**
-* Handle an error from the server.
-*
-* @param session
-* @param msg The message.
-*
-* @return TRUE if successfully reported error.
-*/
-static gboolean
-msim_error(MsimSession *session, MsimMessage *msg)
-{
-	gchar *errmsg, *full_errmsg;
-	guint err;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	g_return_val_if_fail(msg != NULL, FALSE);
-	err = msim_msg_get_integer(msg, "err");
-	errmsg = msim_msg_get_string(msg, "errmsg");
-	full_errmsg = g_strdup_printf(_("Protocol error, code %d: %s"), err,
-			errmsg ? errmsg : "no 'errmsg' given");
-	g_free(errmsg);
-	purple_debug_info("msim", "msim_error (sesskey=%d): %s\n",
-			session->sesskey, full_errmsg);
-	/* Destroy session if fatal. */
-	if (msim_msg_get(msg, "fatal")) {
-		PurpleConnectionError reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
-		purple_debug_info("msim", "fatal error, closing\n");
-		switch (err) {
-			case MSIM_ERROR_INCORRECT_PASSWORD: /* Incorrect password */
-				reason = PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED;
-				if (!purple_account_get_remember_password(session->account))
-					purple_account_set_password(session->account, NULL);
-#ifdef MSIM_MAX_PASSWORD_LENGTH
-				if (session->account->password && (strlen(session->account->password) > MSIM_MAX_PASSWORD_LENGTH)) {
-					gchar *suggestion;
-					suggestion = g_strdup_printf(_("%s Your password is "
-							"%d characters, greater than the "
-							"expected maximum length of %d for "
-							"MySpaceIM. Please shorten your "
-							"password at http://profileedit.myspace.com/index.cfm?fuseaction=accountSettings.changePassword and try again."),
-							full_errmsg, (int)
-							strlen(session->account->password),
-							MSIM_MAX_PASSWORD_LENGTH);
-					/* Replace full_errmsg. */
-					g_free(full_errmsg);
-					full_errmsg = suggestion;
-				}
-#endif
-				break;
-			case MSIM_ERROR_LOGGED_IN_ELSEWHERE: /* Logged in elsewhere */
-				reason = PURPLE_CONNECTION_ERROR_NAME_IN_USE;
-				if (!purple_account_get_remember_password(session->account))
-					purple_account_set_password(session->account, NULL);
-				break;
-		}
-		purple_connection_error_reason (session->gc, reason, full_errmsg);
-	} else {
-		purple_notify_error(session->account, _("MySpaceIM Error"), full_errmsg, NULL);
-	}
-	g_free(full_errmsg);
-	return TRUE;
-}
-/**
-* Process incoming status messages.
-*
-* @param session
-* @param msg Status update message. Caller frees.
-*
-* @return TRUE if successful.
-*/
-static gboolean
-msim_incoming_status(MsimSession *session, MsimMessage *msg)
-{
-	PurpleBuddyList *blist;
-	MsimUser *user;
-	GList *list;
-	gchar *status_headline, *status_headline_escaped;
-	gint status_code, purple_status_code;
-	gchar *username;
-	gchar *unrecognized_msg;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-	g_return_val_if_fail(msg != NULL, FALSE);
-	msim_msg_dump("msim_status msg=%s\n", msg);
-	/* Helpfully looked up by msim_incoming_resolve() for us. */
-	username = msim_msg_get_string(msg, "_username");
-	g_return_val_if_fail(username != NULL, FALSE);
-	{
-		gchar *ss;
-		ss = msim_msg_get_string(msg, "msg");
-		purple_debug_info("msim",
-				"msim_status: updating status for <%s> to <%s>\n",
-				username, ss ? ss : "(NULL)");
-		g_free(ss);
-	}
-	/* Example fields:
-	 *  |s|0|ss|Offline
-	 *  |s|1|ss|:-)|ls||ip|0|p|0
-	 */
-	list = msim_msg_get_list(msg, "msg");
-	status_code = msim_msg_get_integer_from_element(g_list_nth_data(list, MSIM_STATUS_ORDINAL_ONLINE));
-	purple_debug_info("msim", "msim_status: %s's status code = %d\n", username, status_code);
-	status_headline = msim_msg_get_string_from_element(g_list_nth_data(list, MSIM_STATUS_ORDINAL_HEADLINE));
-	blist = purple_get_blist();
-	/* Add buddy if not found.
-	 * TODO: Could this be responsible for #3444? */
-	user = msim_find_user(session, username);
-	if (!user) {
-		PurpleBuddy *buddy;
-		purple_debug_info("msim",
-				"msim_status: making new buddy for %s\n", username);
-		buddy = purple_buddy_new(session->account, username, NULL);
-		purple_blist_add_buddy(buddy, NULL, NULL, NULL);
-		user = msim_get_user_from_buddy(buddy);
-		user->id = msim_msg_get_integer(msg, "f");
-		/* Keep track of the user ID across sessions */
-		purple_blist_node_set_int(&buddy->node, "UserID", user->id);
-		msim_store_user_info(session, msg, NULL);
-	} else {
-		purple_debug_info("msim", "msim_status: found buddy %s\n", username);
-	}
-	if (status_headline && strcmp(status_headline, "") != 0) {
-		/* The status headline is plaintext, but libpurple treats it as HTML,
-		 * so escape any HTML characters to their entity equivalents. */
-		status_headline_escaped = g_markup_escape_text(status_headline, strlen(status_headline));
-	} else {
-		status_headline_escaped = NULL;
-	}
-	g_free(status_headline);
-	if (user->headline)
-		g_free(user->headline);
-	/* don't copy; let the MsimUser own the headline, memory-wise */
-	user->headline = status_headline_escaped;
-	/* Set user status */
-	switch (status_code) {
-		case MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN:
-			purple_status_code = PURPLE_STATUS_OFFLINE;
-			break;
-		case MSIM_STATUS_CODE_ONLINE:
-			purple_status_code = PURPLE_STATUS_AVAILABLE;
-			break;
-		case MSIM_STATUS_CODE_AWAY:
-			purple_status_code = PURPLE_STATUS_AWAY;
-			break;
-		case MSIM_STATUS_CODE_IDLE:
-			/* Treat idle as an available status. */
-			purple_status_code = PURPLE_STATUS_AVAILABLE;
-			break;
-		default:
-			purple_debug_info("msim", "msim_incoming_status for %s, unknown status code %d, treating as available\n",
-						username, status_code);
-			purple_status_code = PURPLE_STATUS_AVAILABLE;
-			unrecognized_msg = g_strdup_printf("msim_incoming_status, unrecognized status code: %d\n",
-					status_code);
-			msim_unrecognized(session, NULL, unrecognized_msg);
-			g_free(unrecognized_msg);
-	}
-	purple_prpl_got_user_status(session->account, username, purple_primitive_get_id_from_type(purple_status_code), NULL);
-	if (status_code == MSIM_STATUS_CODE_IDLE) {
-		purple_debug_info("msim", "msim_status: got idle: %s\n", username);
-		purple_prpl_got_user_idle(session->account, username, TRUE, time(NULL));
-	} else {
-		/* All other statuses indicate going back to non-idle. */
-		purple_prpl_got_user_idle(session->account, username, FALSE, time(NULL));
-	}
-#ifdef MSIM_SEND_CLIENT_VERSION
-	if (status_code == MSIM_STATUS_CODE_ONLINE) {
-		/* Secretly whisper to unofficial clients our own version as they come online */
-		msim_send_unofficial_client(session, username);
-	}
-#endif
-	if (status_code != MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN) {
-		/* Get information when they come online.
-		 * TODO: periodically refresh?
-		 */
-		purple_debug_info("msim_incoming_status", "%s came online, looking up\n", username);
-		msim_lookup_user(session, username, NULL, NULL);
-	}
-	g_free(username);
-	msim_msg_list_free(list);
-	return TRUE;
-}
-/** Add a buddy to user's buddy list. */
-void
-msim_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
-{
-	MsimSession *session;
-	MsimMessage *msg;
-	MsimMessage *msg_persist;
-	MsimMessage *body;
-	session = (MsimSession *)gc->proto_data;
-	purple_debug_info("msim", "msim_add_buddy: want to add %s to %s\n",
-			buddy->name, (group && group->name) ? group->name : "(no group)");
-	msg = msim_msg_new(
-			"addbuddy", MSIM_TYPE_BOOLEAN, TRUE,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			/* "newprofileid" will be inserted here with uid. */
-			"reason", MSIM_TYPE_STRING, g_strdup(""),
-			NULL);
-	if (!msim_postprocess_outgoing(session, msg, buddy->name, "newprofileid", "reason")) {
-		purple_notify_error(NULL, NULL, _("Failed to add buddy"), _("'addbuddy' command failed."));
-		msim_msg_free(msg);
-		return;
-	}
-	msim_msg_free(msg);
-	/* TODO: if addbuddy fails ('error' message is returned), delete added buddy from
-	 * buddy list since Purple adds it locally. */
-	body = msim_msg_new(
-			"ContactID", MSIM_TYPE_STRING, g_strdup("<uid>"),
-			"GroupName", MSIM_TYPE_STRING, g_strdup(group->name),
-			"Position", MSIM_TYPE_INTEGER, 1000,
-			"Visibility", MSIM_TYPE_INTEGER, 1,
-			"NickName", MSIM_TYPE_STRING, g_strdup(""),
-			"NameSelect", MSIM_TYPE_INTEGER, 0,
-			NULL);
-	/* TODO: Update blocklist. */
-	msg_persist = msim_msg_new(
-		"persist", MSIM_TYPE_INTEGER, 1,
-		"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-		"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_BIT_ACTION | MSIM_CMD_PUT,
-		"dsn", MSIM_TYPE_INTEGER, MC_CONTACT_INFO_DSN,
-		"uid", MSIM_TYPE_INTEGER, session->userid,
-		"lid", MSIM_TYPE_INTEGER, MC_CONTACT_INFO_LID,
-		/* TODO: Use msim_new_reply_callback to get rid. */
-		"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-		"body", MSIM_TYPE_DICTIONARY, body,
-		NULL);
-	if (!msim_postprocess_outgoing(session, msg_persist, buddy->name, "body", NULL))
-	{
-		purple_notify_error(NULL, NULL, _("Failed to add buddy"), _("persist command failed"));
-		msim_msg_free(msg_persist);
-		return;
-	}
-	msim_msg_free(msg_persist);
-}
-/** Perform actual postprocessing on a message, adding userid as specified.
-*
-* @param msg The message to postprocess.
-* @param uid_before Name of field where to insert new field before, or NULL for end.
-* @param uid_field_name Name of field to add uid to.
-* @param uid The userid to insert.
-*
-* If the field named by uid_field_name already exists, then its string contents will
-* be used for the field, except "<uid>" will be replaced by the userid.
-*
-* If the field named by uid_field_name does not exist, it will be added before the
-* field named by uid_before, as an integer, with the userid.
-*
-* Does not handle sending, or scheduling userid lookup. For that, see msim_postprocess_outgoing().
-*/
-static MsimMessage *
-msim_do_postprocessing(MsimMessage *msg, const gchar *uid_before,
-		const gchar *uid_field_name, guint uid)
-{
-	MsimMessageElement *elem;
-	msim_msg_dump("msim_do_postprocessing msg: %s\n", msg);
-	/* First, check - if the field already exists, replace <uid> within it */
-	if ((elem = msim_msg_get(msg, uid_field_name)) != NULL) {
-		gchar *fmt_string;
-		gchar *uid_str, *new_str;
-		/* Get the packed element, flattening it. This allows <uid> to be
-		 * replaced within nested data structures, since the replacement is done
-		 * on the linear, packed data, not on a complicated data structure.
-		 *
-		 * For example, if the field was originally a dictionary or a list, you
-		 * would have to iterate over all the items in it to see what needs to
-		 * be replaced. But by packing it first, the <uid> marker is easily replaced
-		 * just by a string replacement.
-		 */
-		fmt_string = msim_msg_pack_element_data(elem);
-		uid_str = g_strdup_printf("%d", uid);
-		new_str = purple_strreplace(fmt_string, "<uid>", uid_str);
-		g_free(uid_str);
-		g_free(fmt_string);
-		/* Free the old element data */
-		msim_msg_free_element_data(elem->data);
-		/* Replace it with our new data */
-		elem->data = new_str;
-		elem->type = MSIM_TYPE_RAW;
-	} else {
-		/* Otherwise, insert new field into outgoing message. */
-		msg = msim_msg_insert_before(msg, uid_before, uid_field_name, MSIM_TYPE_INTEGER, GUINT_TO_POINTER(uid));
-	}
-	msim_msg_dump("msim_postprocess_outgoing_cb: postprocessed msg=%s\n", msg);
-	return msg;
-}
-/** Callback for msim_postprocess_outgoing() to add a userid to a message, and send it (once receiving userid).
-*
-* @param session
-* @param userinfo The user information reply message, containing the user ID
-* @param data The message to postprocess and send.
-*
-* The data message should contain these fields:
-*
-*  _uid_field_name: string, name of field to add with userid from userinfo message
-*  _uid_before: string, name of field before field to insert, or NULL for end
-*
-*
-*/
-static void
-msim_postprocess_outgoing_cb(MsimSession *session, MsimMessage *userinfo,
-		gpointer data)
-{
-	gchar *uid_field_name, *uid_before, *username;
-	guint uid;
-	MsimMessage *msg, *body;
-	msg = (MsimMessage *)data;
-	msim_msg_dump("msim_postprocess_outgoing_cb() got msg=%s\n", msg);
-	/* Obtain userid from userinfo message. */
-	body = msim_msg_get_dictionary(userinfo, "body");
-	g_return_if_fail(body != NULL);
-	uid = msim_msg_get_integer(body, "UserID");
-	msim_msg_free(body);
-	username = msim_msg_get_string(msg, "_username");
-	if (!uid) {
-		gchar *msg;
-		msg = g_strdup_printf(_("No such user: %s"), username);
-		if (!purple_conv_present_error(username, session->account, msg)) {
-			purple_notify_error(NULL, NULL, _("User lookup"), msg);
-		}
-		g_free(msg);
-		g_free(username);
-		/* TODO: free
-		 * msim_msg_free(msg);
-		 */
-		return;
-	}
-	uid_field_name = msim_msg_get_string(msg, "_uid_field_name");
-	uid_before = msim_msg_get_string(msg, "_uid_before");
-	msg = msim_do_postprocessing(msg, uid_before, uid_field_name, uid);
-	/* Send */
-	if (!msim_msg_send(session, msg)) {
-		msim_msg_dump("msim_postprocess_outgoing_cb: sending failed for message: %s\n", msg);
-	}
-	/* Free field names AFTER sending message, because MsimMessage does NOT copy
-	 * field names - instead, treats them as static strings (which they usually are).
-	 */
-	g_free(uid_field_name);
-	g_free(uid_before);
-	g_free(username);
-	/* TODO: free
-	 * msim_msg_free(msg);
-	 */
-}
-/** Postprocess and send a message.
-*
-* @param session
-* @param msg Message to postprocess. Will NOT be freed.
-* @param username Username to resolve. Assumed to be a static string (will not be freed or copied).
-* @param uid_field_name Name of new field to add, containing uid of username. Static string.
-* @param uid_before Name of existing field to insert username field before. Static string.
-*
-* @return TRUE if successful.
-*/
-gboolean
-msim_postprocess_outgoing(MsimSession *session, MsimMessage *msg,
-		const gchar *username, const gchar *uid_field_name,
-		const gchar *uid_before)
-{
-	PurpleBuddy *buddy;
-	guint uid;
-	gboolean rc;
-	g_return_val_if_fail(msg != NULL, FALSE);
-	/* Store information for msim_postprocess_outgoing_cb(). */
-	msim_msg_dump("msim_postprocess_outgoing: msg before=%s\n", msg);
-	msg = msim_msg_append(msg, "_username", MSIM_TYPE_STRING, g_strdup(username));
-	msg = msim_msg_append(msg, "_uid_field_name", MSIM_TYPE_STRING, g_strdup(uid_field_name));
-	msg = msim_msg_append(msg, "_uid_before", MSIM_TYPE_STRING, g_strdup(uid_before));
-	/* First, try the most obvious. If numeric userid is given, use that directly. */
-	if (msim_is_userid(username)) {
-		uid = atol(username);
-	} else {
-		/* Next, see if on buddy list and know uid. */
-		buddy = purple_find_buddy(session->account, username);
-		if (buddy) {
-			uid = purple_blist_node_get_int(&buddy->node, "UserID");
 		} else {
-			uid = 0;
+			gchar *from;
-		}
+			/* Send lookup request. */
-		if (!buddy || !uid) {
+			/* XXX: where is msim_msg_get_string() freed? make _strdup and _nonstrdup. */
-			/* Don't have uid offhand - need to ask for it, and wait until hear back before sending. */
+			purple_debug_info("msim", "msim_incoming: sending lookup, setting up callback\n");
-			purple_debug_info("msim", ">>> msim_postprocess_outgoing: couldn't find username %s in blist\n",
+			from = msim_msg_get_string(msg, "f");
-					username ? username : "(NULL)");
+			msim_lookup_user(session, from, msim_incoming_resolved, msim_msg_clone(msg));
-			msim_msg_dump("msim_postprocess_outgoing - scheduling lookup, msg=%s\n", msg);
+			g_free(from);
-			/* TODO: where is cloned message freed? Should be in _cb. */
-			msim_lookup_user(session, username, msim_postprocess_outgoing_cb, msim_msg_clone(msg));
+			/* indeterminate */
-			return TRUE;       /* not sure of status yet - haven't sent! */
+			return TRUE;
-		}
-	}
-	/* Already have uid, postprocess and send msg immediately. */
-	purple_debug_info("msim", "msim_postprocess_outgoing: found username %s has uid %d\n",
-			username ? username : "(NULL)", uid);
-	msg = msim_do_postprocessing(msg, uid_before, uid_field_name, uid);
-	msim_msg_dump("msim_postprocess_outgoing: msg after (uid immediate)=%s\n", msg);
-	rc = msim_msg_send(session, msg);
-	/* TODO: free
-	 * msim_msg_free(msg);
-	 */
-	return rc;
-}
-/** Remove a buddy from the user's buddy list. */
-void
-msim_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
-{
-	MsimSession *session;
-	MsimMessage *delbuddy_msg;
-	MsimMessage *persist_msg;
-	MsimMessage *blocklist_msg;
-	GList *blocklist_updates;
-	session = (MsimSession *)gc->proto_data;
-	delbuddy_msg = msim_msg_new(
-				"delbuddy", MSIM_TYPE_BOOLEAN, TRUE,
-				"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-				/* 'delprofileid' with uid will be inserted here. */
-				NULL);
-	if (!msim_postprocess_outgoing(session, delbuddy_msg, buddy->name, "delprofileid", NULL)) {
-		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("'delbuddy' command failed"));
-		msim_msg_free(delbuddy_msg);
-		return;
-	}
-	msim_msg_free(delbuddy_msg);
-	persist_msg = msim_msg_new(
-			"persist", MSIM_TYPE_INTEGER, 1,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_BIT_ACTION | MSIM_CMD_DELETE,
-			"dsn", MSIM_TYPE_INTEGER, MD_DELETE_BUDDY_DSN,
-			"lid", MSIM_TYPE_INTEGER, MD_DELETE_BUDDY_LID,
-			"uid", MSIM_TYPE_INTEGER, session->userid,
-			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-			/* <uid> will be replaced by postprocessing */
-			"body", MSIM_TYPE_STRING, g_strdup("ContactID=<uid>"),
-			NULL);
-	if (!msim_postprocess_outgoing(session, persist_msg, buddy->name, "body", NULL)) {
-		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("persist command failed"));
-		msim_msg_free(persist_msg);
-		return;
-	}
-	msim_msg_free(persist_msg);
-	blocklist_updates = NULL;
-	blocklist_updates = g_list_prepend(blocklist_updates, "a-");
-	blocklist_updates = g_list_prepend(blocklist_updates, "<uid>");
-	blocklist_updates = g_list_prepend(blocklist_updates, "b-");
-	blocklist_updates = g_list_prepend(blocklist_updates, "<uid>");
-	blocklist_updates = g_list_reverse(blocklist_updates);
-	blocklist_msg = msim_msg_new(
-			"blocklist", MSIM_TYPE_BOOLEAN, TRUE,
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			/* TODO: MsimMessage lists. Currently <uid> isn't replaced in lists. */
-			/* "idlist", MSIM_TYPE_STRING, g_strdup("a-|<uid>|b-|<uid>"), */
-			"idlist", MSIM_TYPE_LIST, blocklist_updates,
-			NULL);
-	if (!msim_postprocess_outgoing(session, blocklist_msg, buddy->name, "idlist", NULL)) {
-		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("blocklist command failed"));
-		msim_msg_free(blocklist_msg);
-		return;
-	}
-	msim_msg_free(blocklist_msg);
-}
-/**
-* Returns a string of a username in canonical form. Basically removes all the
-* spaces, lowercases the string, and looks up user IDs to usernames.
-* Normalizing tom, TOM, Tom, and 6221 wil all return 'tom'.
-*
-* Borrowed this code from oscar_normalize. Added checking for
-* "if userid, get name before normalizing"
-*/
-const char *msim_normalize(const PurpleAccount *account, const char *str) {
-	static char normalized[BUF_LEN];
-	char *tmp1, *tmp2;
-	int i, j;
-	guint id;
-	g_return_val_if_fail(str != NULL, NULL);
-	if (msim_is_userid(str)) {
-		/* Have user ID, we need to get their username first :) */
-		const char *username;
-		/* If the account does not exist, we can't look up the user. */
-		if (!account || !account->gc)
-			return str;
-		id = atol(str);
-		username = msim_uid2username_from_blist((PurpleAccount *)account, id);
-		if (!username) {
-			/* Not in buddy list... scheisse... TODO: Manual Lookup! Bug #4631 */
-			/* Note: manual lookup using msim_lookup_user() is a problem inside
-			 * msim_normalize(), because msim_lookup_user() calls a callback function
-			 * when the user information has been looked up, but msim_normalize() expects
-			 * the result immediately. */
-			strncpy(normalized, str, BUF_LEN);
-		} else {
-			strncpy(normalized, username, BUF_LEN);
 		}
 	} else {
-		/* Have username. */
+		/* Nothing to resolve - send directly to processing. */
-		strncpy(normalized, str, BUF_LEN);
+		return msim_process(session, msg);
 	}
-	/* Strip spaces. */
-	for (i=0, j=0; normalized[j]; i++, j++) {
-		while (normalized[j] == ' ')
-			j++;
-		normalized[i] = normalized[j];
-	}
-	normalized[i] = '\0';
-	/* Lowercase and perform UTF-8 normalization. */
-	tmp1 = g_utf8_strdown(normalized, -1);
-	tmp2 = g_utf8_normalize(tmp1, -1, G_NORMALIZE_DEFAULT);
-	g_snprintf(normalized, sizeof(normalized), "%s", tmp2);
-	g_free(tmp2);
-	g_free(tmp1);
-	/* TODO: re-add caps and spacing back to what the user wanted.
-	 * User can format their own names, for example 'msimprpl' is shown
-	 * as 'MsIm PrPl' in the official client.
-	 *
-	 * TODO: file a ticket to add this enhancement.
-	 */
-	return normalized;
-}
-static GHashTable *
-msim_get_account_text_table(PurpleAccount *unused)
-{
-	GHashTable *table;
-	table = g_hash_table_new(g_str_hash, g_str_equal);
-	g_hash_table_insert(table, "login_label", (gpointer)_("Email Address..."));
-	return table;
-}
-/** Return whether the buddy can be messaged while offline.
-*
-* The protocol supports offline messages in just the same way as online
-* messages.
-*/
-gboolean
-msim_offline_message(const PurpleBuddy *buddy)
-{
-	return TRUE;
 }
 /**
 * Callback when input available.
 *
 * @param source File descriptor.
 * @param cond PURPLE_INPUT_READ
 *
 * Reads the input, and calls msim_preprocess_incoming() to handle it.
 */
 static void
 msim_input_cb(gpointer gc_uncasted, gint source, PurpleInputCondition cond)
 {
 	PurpleConnection *gc;
 	PurpleAccount *account;
 	MsimSession *session;
 	/* Mark down that we got data, so we don't timeout. */
 	session->last_comm = time(NULL);
 	/* If approaching end of buffer, reallocate some more memory. */
 	if (session->rxsize < session->rxoff + MSIM_READ_BUF_SIZE) {
 		purple_debug_info("msim",
 			"msim_input_cb: %d-byte read buffer full, rxoff=%d, " "growing by %d bytes\n",
 			session->rxsize, session->rxoff, MSIM_READ_BUF_SIZE);
 			session->rxsize += MSIM_READ_BUF_SIZE;
 			session->rxbuf = g_realloc(session->rxbuf, session->rxsize);
 		return;
 	}
 	purple_debug_info("msim", "dynamic buffer at %d (max %d), reading up to %d\n",
 			session->rxoff, session->rxsize,
 			MSIM_READ_BUF_SIZE - session->rxoff - 1);
 	/* Read into buffer. On Win32, need recv() not read(). session->fd also holds
 	 * the file descriptor, but it sometimes differs from the 'source' parameter.
 	 */
 	n = recv(session->fd,
 		 session->rxbuf + session->rxoff,
 		 session->rxsize - session->rxoff - 1, 0);
 	if (n < 0 && errno == EAGAIN) {
 		return;
 	} else if (n < 0) {
 		purple_debug_error("msim", "msim_input_cb: read error, ret=%d, "
 			"error=%s, source=%d, fd=%d (%X))\n",
 			n, g_strerror(errno), source, session->fd, session->fd);
 		purple_connection_error_reason (gc,
 			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
 			_("Read error"));
 		return;
 	} else if (n == 0) {
 		purple_debug_info("msim", "msim_input_cb: server disconnected\n");
 #ifdef MSIM_CHECK_EMBEDDED_NULLS
 	/* Check for embedded NULs. I don't handle them, and they shouldn't occur. */
 	if (strlen(session->rxbuf + session->rxoff) != n) {
 		/* Occurs after login, but it is not a null byte. */
 		purple_debug_info("msim", "msim_input_cb: strlen=%d, but read %d bytes"
 				"--null byte encountered?\n",
 				strlen(session->rxbuf + session->rxoff), n);
 		/*purple_connection_error_reason (gc,
 				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
 				"Invalid message - null byte on input"); */
 		return;
 			msim_msg_free(msg);
 		}
 		/* Move remaining part of buffer to beginning. */
 		session->rxoff -= strlen(session->rxbuf) + strlen(MSIM_FINAL_STRING);
 		memmove(session->rxbuf, end + strlen(MSIM_FINAL_STRING),
 				session->rxsize - (end + strlen(MSIM_FINAL_STRING) - session->rxbuf));
 		/* Clear end of buffer
 		 * memset(end, 0, MSIM_READ_BUF_SIZE - (end - session->rxbuf));
 		 */
 	}
-}
-/* Setup a callback, to be called when a reply is received with the returned rid.
-*
-* @param cb The callback, an MSIM_USER_LOOKUP_CB.
-* @param data Arbitrary user data to be passed to callback (probably an MsimMessage *).
-*
-* @return The request/reply ID, used to link replies with requests, or -1.
-*          Put the rid in your request, 'rid' field.
-*
-* TODO: Make more generic and more specific:
-* 1) MSIM_USER_LOOKUP_CB - make it for PERSIST_REPLY, not just user lookup
-* 2) data - make it an MsimMessage?
-*/
-guint
-msim_new_reply_callback(MsimSession *session, MSIM_USER_LOOKUP_CB cb,
-		gpointer data)
-{
-	guint rid;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
-	rid = session->next_rid++;
-	g_hash_table_insert(session->user_lookup_cb, GUINT_TO_POINTER(rid), cb);
-	g_hash_table_insert(session->user_lookup_cb_data, GUINT_TO_POINTER(rid), data);
-	return rid;
 }
 /**
 * Callback when connected. Sets up input handlers.
 *
 * @param data A PurpleConnection pointer.
 * @param source File descriptor.
 * @param error_message
 */
 static void
 msim_connect_cb(gpointer data, gint source, const gchar *error_message)
 {
 	PurpleConnection *gc;
 	MsimSession *session;
 	session = (MsimSession *)gc->proto_data;
 	if (source < 0) {
 		purple_connection_error_reason (gc,
 			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
 			g_strdup_printf(_("Couldn't connect to host: %s (%d)"),
 					error_message ? error_message : "no message given",
 					source));
 		return;
 	}
 	session->fd = source;
 	gc->inpa = purple_input_add(source, PURPLE_INPUT_READ, msim_input_cb, gc);
 }
+/**
-/**
+* Start logging in to the MSIM servers.
+*
+* @param acct Account information to use to login.
+*/
+static void
+msim_login(PurpleAccount *acct)
+{
+	PurpleConnection *gc;
+	const gchar *host;
+	int port;
+	g_return_if_fail(acct != NULL);
+	g_return_if_fail(acct->username != NULL);
+	purple_debug_info("msim", "logging in %s\n", acct->username);
+	gc = purple_account_get_connection(acct);
+	gc->proto_data = msim_session_new(acct);
+	gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_URLDESC;
+	/* 1. connect to server */
+	purple_connection_update_progress(gc, _("Connecting"),
+								  0,   /* which connection step this is */
+								  4);  /* total number of steps */
+	host = purple_account_get_string(acct, "server", MSIM_SERVER);
+	port = purple_account_get_int(acct, "port", MSIM_PORT);
+	/* From purple.sf.net/api:
+	 * """Note that this function name can be misleading--although it is called
+	 * "proxy connect," it is used for establishing any outgoing TCP connection,
+	 * whether through a proxy or not.""" */
+	/* Calls msim_connect_cb when connected. */
+	if (!purple_proxy_connect(gc, acct, host, port, msim_connect_cb, gc)) {
+		/* TODO: try other ports if in auto mode, then save
+		 * working port and try that first next time. */
+		purple_connection_error_reason (gc,
+			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
+			_("Couldn't create socket"));
+		return;
+	}
+}
+/**
 * Close the connection.
 *
 * @param gc The connection.
 */
-void
+static void
 msim_close(PurpleConnection *gc)
 {
 	MsimSession *session;
 	if (gc == NULL) {
 	}
 	msim_session_destroy(session);
 }
+/**
-/**
+* Schedule an IM to be sent once the user ID is looked up.
-* Obtain the status text for a buddy.
+*
-*
+* @param gc Connection.
-* @param buddy The buddy to obtain status text for.
+* @param who A user id, email, or username to send the message to.
-*
+* @param message Instant message text to send.
-* @return Status text, or NULL if error. Caller g_free()'s.
+* @param flags Flags.
 *
-*/
+* @return 1 if successful or postponed, -1 if failed
-char *
+*
-msim_status_text(PurpleBuddy *buddy)
+* Allows sending to a user by username, email address, or userid. If
+* a username or email address is given, the userid must be looked up.
+* This function does that by calling msim_postprocess_outgoing().
+*/
+static int
+msim_send_im(PurpleConnection *gc, const gchar *who, const gchar *message,
+		PurpleMessageFlags flags)
+{
+	MsimSession *session;
+	gchar *message_msim;
+	int rc;
+	g_return_val_if_fail(gc != NULL, -1);
+	g_return_val_if_fail(who != NULL, -1);
+	g_return_val_if_fail(message != NULL, -1);
+	/* 'flags' has many options, not used here. */
+	session = (MsimSession *)gc->proto_data;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
+	message_msim = html_to_msim_markup(session, message);
+	if (msim_send_bm(session, who, message_msim, MSIM_BM_INSTANT)) {
+		/* Return 1 to have Purple show this IM as being sent, 0 to not. I always
+		 * return 1 even if the message could not be sent, since I don't know if
+		 * it has failed yet--because the IM is only sent after the userid is
+		 * retrieved from the server (which happens after this function returns).
+		 * If an error does occur, it should be logged to the IM window.
+		 */
+		rc = 1;
+	} else {
+		rc = -1;
+	}
+	g_free(message_msim);
+	return rc;
+}
+/**
+* Handle when our user starts or stops typing to another user.
+*
+* @param gc
+* @param name The buddy name to which our user is typing to
+* @param state PURPLE_TYPING, PURPLE_TYPED, PURPLE_NOT_TYPING
+*
+* @return 0
+*/
+static unsigned int
+msim_send_typing(PurpleConnection *gc, const gchar *name,
+		PurpleTypingState state)
+{
+	const gchar *typing_str;
+	MsimSession *session;
+	g_return_val_if_fail(gc != NULL, 0);
+	g_return_val_if_fail(name != NULL, 0);
+	session = (MsimSession *)gc->proto_data;
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), 0);
+	switch (state) {
+		case PURPLE_TYPING:
+			typing_str = "%typing%";
+			break;
+		case PURPLE_TYPED:
+		case PURPLE_NOT_TYPING:
+		default:
+			typing_str = "%stoptyping%";
+			break;
+	}
+	purple_debug_info("msim", "msim_send_typing(%s): %d (%s)\n", name, state, typing_str);
+	msim_send_bm(session, name, typing_str, MSIM_BM_ACTION);
+	return 0;
+}
+/**
+* Callback for msim_get_info(), for when user info is received.
+*/
+static void
+msim_get_info_cb(MsimSession *session, MsimMessage *user_info_msg,
+		gpointer data)
+{
+	MsimMessage *msg;
+	gchar *username;
+	PurpleNotifyUserInfo *user_info;
+	MsimUser *user;
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	/* Get user{name,id} from msim_get_info, passed as an MsimMessage for
+	   orthogonality. */
+	msg = (MsimMessage *)data;
+	g_return_if_fail(msg != NULL);
+	username = msim_msg_get_string(msg, "user");
+	if (!username) {
+		purple_debug_info("msim", "msim_get_info_cb: no 'user' in msg\n");
+		return;
+	}
+	msim_msg_free(msg);
+	purple_debug_info("msim", "msim_get_info_cb: got for user: %s\n", username);
+	user = msim_find_user(session, username);
+	if (!user) {
+		/* User isn't on blist, create a temporary user to store info. */
+		user = g_new0(MsimUser, 1);
+		user->temporary_user = TRUE;
+	}
+	/* Update user structure with new information */
+	msim_store_user_info(session, user_info_msg, user);
+	user_info = purple_notify_user_info_new();
+	/* Append data from MsimUser to PurpleNotifyUserInfo for display, full */
+	msim_append_user_info(session, user_info, user, TRUE);
+	purple_notify_userinfo(session->gc, username, user_info, NULL, NULL);
+	purple_debug_info("msim", "msim_get_info_cb: username=%s\n", username);
+	purple_notify_user_info_destroy(user_info);
+	if (user->temporary_user) {
+		g_free(user->client_info);
+		g_free(user->gender);
+		g_free(user->location);
+		g_free(user->headline);
+		g_free(user->display_name);
+		g_free(user->username);
+		g_free(user->image_url);
+		g_free(user);
+	}
+	g_free(username);
+}
+/**
+* Retrieve a user's profile.
+* @param username Username, user ID, or email address to lookup.
+*/
+static void
+msim_get_info(PurpleConnection *gc, const gchar *username)
 {
 	MsimSession *session;
 	MsimUser *user;
-	const gchar *display_name, *headline;
+	gchar *user_to_lookup;
+	MsimMessage *user_msg;
-	g_return_val_if_fail(buddy != NULL, NULL);
+	g_return_if_fail(gc != NULL);
-	user = msim_get_user_from_buddy(buddy);
+	g_return_if_fail(username != NULL);
-	session = (MsimSession *)buddy->account->gc->proto_data;
+	session = (MsimSession *)gc->proto_data;
-	g_return_val_if_fail(MSIM_SESSION_VALID(session), NULL);
+	g_return_if_fail(MSIM_SESSION_VALID(session));
-	display_name = headline = NULL;
+	/* Obtain uid of buddy. */
-	/* Retrieve display name and/or headline, depending on user preference. */
+	user = msim_find_user(session, username);
-	if (purple_account_get_bool(session->account, "show_headline", TRUE)) {
-		headline = user->headline;
+	/* If is on buddy list, lookup by uid since it is faster. */
-	}
+	if (user && user->id) {
+		user_to_lookup = g_strdup_printf("%d", user->id);
-	if (purple_account_get_bool(session->account, "show_display_name", FALSE)) {
+	} else {
-		display_name = user->display_name;
+		/* Looking up buddy not on blist. Lookup by whatever user entered. */
-	}
+		user_to_lookup = g_strdup(username);
+	}
-	/* Return appropriate combination of display name and/or headline, or neither. */
+	/* Pass the username to msim_get_info_cb(), because since we lookup
-	if (display_name && headline) {
+	 * by userid, the userinfo message will only contain the uid (not
-		return g_strconcat(display_name, " ", headline, NULL);
+	 * the username) but it would be useful to display the username too.
-	} else if (display_name) {
+	 */
-		return g_strdup(display_name);
+	user_msg = msim_msg_new(
-	} else if (headline) {
+			"user", MSIM_TYPE_STRING, g_strdup(username),
-		return g_strdup(headline);
+			NULL);
-	}
+	purple_debug_info("msim", "msim_get_info, setting up lookup, user=%s\n", username);
-	return NULL;
+	msim_lookup_user(session, user_to_lookup, msim_get_info_cb, user_msg);
-}
+	g_free(user_to_lookup);
-/**
+}
-* Obtain the tooltip text for a buddy.
-*
+/**
-* @param buddy Buddy to obtain tooltip text on.
+* Set status using an MSIM_STATUS_CODE_* value.
-* @param user_info Variable modified to have the tooltip text.
+* @param status_code An MSIM_STATUS_CODE_* value.
-* @param full TRUE if should obtain full tooltip text.
+* @param statstring Status string, must be a dynamic string (will be freed by msim_send).
-*
+*/
-*/
+static void
-void
+msim_set_status_code(MsimSession *session, guint status_code, gchar *statstring)
-msim_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info,
+{
-		gboolean full)
+	g_return_if_fail(MSIM_SESSION_VALID(session));
-{
+	g_return_if_fail(statstring != NULL);
-	MsimUser *user;
+	purple_debug_info("msim", "msim_set_status_code: going to set status to code=%d,str=%s\n",
-	g_return_if_fail(buddy != NULL);
+			status_code, statstring);
-	g_return_if_fail(user_info != NULL);
+	if (!msim_send(session,
-	user = msim_get_user_from_buddy(buddy);
+			"status", MSIM_TYPE_INTEGER, status_code,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-	if (PURPLE_BUDDY_IS_ONLINE(buddy)) {
+			"statstring", MSIM_TYPE_STRING, statstring,
-		MsimSession *session;
+			"locstring", MSIM_TYPE_STRING, g_strdup(""),
+			NULL))
-		session = (MsimSession *)buddy->account->gc->proto_data;
+	{
+		purple_debug_info("msim", "msim_set_status: failed to set status\n");
-		g_return_if_fail(MSIM_SESSION_VALID(session));
+	}
+}
-		/* TODO: if (full), do something different? */
+/**
-		/* TODO: request information? have to figure out how to do
+* Set your status - callback for when user manually sets it.
-		 * the asynchronous lookup like oscar does (tooltip shows
+*/
-		 * 'retrieving...' if not yet available, then changes when it is).
+static void
-		 *
+msim_set_status(PurpleAccount *account, PurpleStatus *status)
-		 * Right now, only show what we have on hand.
+{
+	PurpleStatusType *type;
+	PurplePresence *pres;
+	MsimSession *session;
+	guint status_code;
+	const gchar *message;
+	gchar *stripped;
+	gchar *unrecognized_msg;
+	session = (MsimSession *)account->gc->proto_data;
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	type = purple_status_get_type(status);
+	pres = purple_status_get_presence(status);
+	switch (purple_status_type_get_primitive(type)) {
+		case PURPLE_STATUS_AVAILABLE:
+			purple_debug_info("msim", "msim_set_status: available (%d->%d)\n", PURPLE_STATUS_AVAILABLE,
+					MSIM_STATUS_CODE_ONLINE);
+			status_code = MSIM_STATUS_CODE_ONLINE;
+			break;
+		case PURPLE_STATUS_INVISIBLE:
+			purple_debug_info("msim", "msim_set_status: invisible (%d->%d)\n", PURPLE_STATUS_INVISIBLE,
+					MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN);
+			status_code = MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN;
+			break;
+		case PURPLE_STATUS_AWAY:
+			purple_debug_info("msim", "msim_set_status: away (%d->%d)\n", PURPLE_STATUS_AWAY,
+					MSIM_STATUS_CODE_AWAY);
+			status_code = MSIM_STATUS_CODE_AWAY;
+			break;
+		default:
+			purple_debug_info("msim", "msim_set_status: unknown "
+					"status interpreting as online");
+			status_code = MSIM_STATUS_CODE_ONLINE;
+			unrecognized_msg = g_strdup_printf("msim_set_status, unrecognized status type: %d\n",
+					purple_status_type_get_primitive(type));
+			msim_unrecognized(session, NULL, unrecognized_msg);
+			g_free(unrecognized_msg);
+			break;
+	}
+	message = purple_status_get_attr_string(status, "message");
+	/* Status strings are plain text. */
+	if (message != NULL)
+		stripped = purple_markup_strip_html(message);
+	else
+		stripped = g_strdup("");
+	msim_set_status_code(session, status_code, stripped);
+	/* If we should be idle, set that status. Time is irrelevant here. */
+	if (purple_presence_is_idle(pres) && status_code != MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN)
+		msim_set_idle(account->gc, 1);
+}
+/**
+* Go idle.
+*/
+static void
+msim_set_idle(PurpleConnection *gc, int time)
+{
+	MsimSession *session;
+	PurpleStatus *status;
+	g_return_if_fail(gc != NULL);
+	session = (MsimSession *)gc->proto_data;
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	status = purple_account_get_active_status(session->account);
+	if (time == 0) {
+		/* Going back from idle. In msim, idle is mutually exclusive
+		 * from the other states (you can only be away or idle, but not
+		 * both, for example), so by going non-idle I go back to what
+		 * libpurple says I should be.
 		 */
+		msim_set_status(session->account, status);
-		/* Show abbreviated user info. */
+	} else {
-		msim_append_user_info(session, user_info, user, FALSE);
+		const gchar *message;
-	}
+		gchar *stripped;
-}
+		/* Set the idle message to the status message from the real
-/** Add contact from server to buddy list, after looking up username.
+		 * current status.
-* Callback from msim_add_contact_from_server().
+		 */
-*
+		message = purple_status_get_attr_string(status, "message");
-* @param data An MsimMessage * of the contact information. Will be freed.
+		if (message != NULL)
+			stripped = purple_markup_strip_html(message);
+		else
+			stripped = g_strdup("");
+		/* msim doesn't support idle time, so just go idle */
+		msim_set_status_code(session, MSIM_STATUS_CODE_IDLE, stripped);
+	}
+}
+/**
+* Add a buddy to user's buddy list.
 */
 static void
-msim_add_contact_from_server_cb(MsimSession *session, MsimMessage *user_lookup_info, gpointer data)
+msim_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
 {
-	MsimMessage *contact_info, *user_lookup_info_body;
+	MsimSession *session;
-	PurpleGroup *group;
+	MsimMessage *msg;
-	PurpleBuddy *buddy;
+	MsimMessage *msg_persist;
-	MsimUser *user;
+	MsimMessage *body;
-	gchar *username, *group_name;
-	guint uid;
+	session = (MsimSession *)gc->proto_data;
+	purple_debug_info("msim", "msim_add_buddy: want to add %s to %s\n",
-	contact_info = (MsimMessage *)data;
+			buddy->name, (group && group->name) ? group->name : "(no group)");
-	purple_debug_info("msim_add_contact_from_server_cb", "contact_info addr=%p\n", contact_info);
-	uid = msim_msg_get_integer(contact_info, "ContactID");
+	msg = msim_msg_new(
+			"addbuddy", MSIM_TYPE_BOOLEAN, TRUE,
-	if (!user_lookup_info) {
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-		username = g_strdup(msim_uid2username_from_blist(session->account, uid));
+			/* "newprofileid" will be inserted here with uid. */
-		g_return_if_fail(username != NULL);
+			"reason", MSIM_TYPE_STRING, g_strdup(""),
-	} else {
+			NULL);
-		user_lookup_info_body = msim_msg_get_dictionary(user_lookup_info, "body");
-		username = msim_msg_get_string(user_lookup_info_body, "UserName");
+	if (!msim_postprocess_outgoing(session, msg, buddy->name, "newprofileid", "reason")) {
-		msim_msg_free(user_lookup_info_body);
+		purple_notify_error(NULL, NULL, _("Failed to add buddy"), _("'addbuddy' command failed."));
-		g_return_if_fail(username != NULL);
+		msim_msg_free(msg);
-	}
+		return;
+	}
-	purple_debug_info("msim_add_contact_from_server_cb",
+	msim_msg_free(msg);
-			"*** about to add/update username=%s\n", username);
+	/* TODO: if addbuddy fails ('error' message is returned), delete added buddy from
-	/* 1. Creates a new group, or gets existing group if it exists (or so
+	 * buddy list since Purple adds it locally. */
-	 * the documentation claims). */
-	group_name = msim_msg_get_string(contact_info, "GroupName");
+	body = msim_msg_new(
-	if (!group_name || (*group_name == '\0')) {
+			"ContactID", MSIM_TYPE_STRING, g_strdup("<uid>"),
-		g_free(group_name);
+			"GroupName", MSIM_TYPE_STRING, g_strdup(group->name),
-		group_name = g_strdup(_("IM Friends"));
+			"Position", MSIM_TYPE_INTEGER, 1000,
-		purple_debug_info("myspace", "No GroupName specified, defaulting to '%s'.\n", group_name);
+			"Visibility", MSIM_TYPE_INTEGER, 1,
-	}
+			"NickName", MSIM_TYPE_STRING, g_strdup(""),
-	group = purple_find_group(group_name);
+			"NameSelect", MSIM_TYPE_INTEGER, 0,
-	if (!group) {
+			NULL);
-		group = purple_group_new(group_name);
-		/* Add group to beginning. See #2752. */
+	/* TODO: Update blocklist. */
-		purple_blist_add_group(group, NULL);
-	}
+	msg_persist = msim_msg_new(
-	g_free(group_name);
+		"persist", MSIM_TYPE_INTEGER, 1,
+		"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-	/* 2. Get or create buddy */
+		"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_BIT_ACTION | MSIM_CMD_PUT,
-	buddy = purple_find_buddy(session->account, username);
+		"dsn", MSIM_TYPE_INTEGER, MC_CONTACT_INFO_DSN,
-	if (!buddy) {
+		"uid", MSIM_TYPE_INTEGER, session->userid,
-		purple_debug_info("msim_add_contact_from_server_cb",
+		"lid", MSIM_TYPE_INTEGER, MC_CONTACT_INFO_LID,
-				"creating new buddy: %s\n", username);
+		/* TODO: Use msim_new_reply_callback to get rid. */
-		buddy = purple_buddy_new(session->account, username, NULL);
+		"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-	}
+		"body", MSIM_TYPE_DICTIONARY, body,
+		NULL);
-	/* TODO: use 'Position' in contact_info to take into account where buddy is */
-	purple_blist_add_buddy(buddy, NULL, group, NULL /* insertion point */);
+	if (!msim_postprocess_outgoing(session, msg_persist, buddy->name, "body", NULL))
+	{
-	/* 3. Update buddy information */
+		purple_notify_error(NULL, NULL, _("Failed to add buddy"), _("persist command failed"));
-	user = msim_get_user_from_buddy(buddy);
+		msim_msg_free(msg_persist);
+		return;
-	user->id = uid;
+	}
-	/* Keep track of the user ID across sessions */
+	msim_msg_free(msg_persist);
-	purple_blist_node_set_int(&buddy->node, "UserID", uid);
+}
-	/* Stores a few fields in the MsimUser, relevant to the buddy itself.
+/**
-	 * AvatarURL, Headline, ContactID. */
+* Remove a buddy from the user's buddy list.
-	msim_store_user_info(session, contact_info, NULL);
+*/
-	/* TODO: other fields, store in 'user' */
-	msim_msg_free(contact_info);
-	g_free(username);
-}
-/** Add first ContactID in contact_info to buddy's list. Used to add
-* server-side buddies to client-side list.
-*
-* @return TRUE if added.
-* */
-static gboolean
-msim_add_contact_from_server(MsimSession *session, MsimMessage *contact_info)
-{
-	guint uid;
-	const gchar *username;
-	uid = msim_msg_get_integer(contact_info, "ContactID");
-	g_return_val_if_fail(uid != 0, FALSE);
-	/* Lookup the username, since NickName and IMName is unreliable */
-	username = msim_uid2username_from_blist(session->account, uid);
-	if (!username) {
-		gchar *uid_str;
-		uid_str = g_strdup_printf("%d", uid);
-		purple_debug_info("msim_add_contact_from_server",
-				"contact_info addr=%p\n", contact_info);
-		msim_lookup_user(session, uid_str, msim_add_contact_from_server_cb, (gpointer)msim_msg_clone(contact_info));
-		g_free(uid_str);
-	} else {
-		msim_add_contact_from_server_cb(session, NULL, (gpointer)msim_msg_clone(contact_info));
-	}
-	/* Say that the contact was added, even if we're still looking up
-	 * their username. */
-	return TRUE;
-}
-/** Called when contact list is received from server. */
 static void
-msim_got_contact_list(MsimSession *session, MsimMessage *reply, gpointer user_data)
+msim_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
 {
-	MsimMessage *body, *body_node;
+	MsimSession *session;
-	gchar *msg;
+	MsimMessage *delbuddy_msg;
-	guint buddy_count;
+	MsimMessage *persist_msg;
+	MsimMessage *blocklist_msg;
-	msim_msg_dump("msim_got_contact_list: reply=%s", reply);
+	GList *blocklist_updates;
-	body = msim_msg_get_dictionary(reply, "body");
+	session = (MsimSession *)gc->proto_data;
-	if (!body) {
-		/* No friends. Not an error. */
+	delbuddy_msg = msim_msg_new(
+				"delbuddy", MSIM_TYPE_BOOLEAN, TRUE,
+				"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+				/* 'delprofileid' with uid will be inserted here. */
+				NULL);
+	if (!msim_postprocess_outgoing(session, delbuddy_msg, buddy->name, "delprofileid", NULL)) {
+		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("'delbuddy' command failed"));
+		msim_msg_free(delbuddy_msg);
 		return;
 	}
+	msim_msg_free(delbuddy_msg);
-	buddy_count = 0;
+	persist_msg = msim_msg_new(
-	for (body_node = body;
-		body_node != NULL;
-		body_node = msim_msg_get_next_element_node(body_node))
-	{
-		MsimMessageElement *elem;
-		elem = (MsimMessageElement *)body_node->data;
-		if (g_str_equal(elem->name, "ContactID"))
-		{
-			/* Will look for first contact in body_node */
-			if (msim_add_contact_from_server(session, body_node)) {
-				++buddy_count;
-			}
-		}
-	}
-	switch (GPOINTER_TO_UINT(user_data)) {
-		case MSIM_CONTACT_LIST_IMPORT_ALL_FRIENDS:
-		        msg = g_strdup_printf(ngettext("%d buddy was added or updated from the server (including buddies already on the server-side list)",
-						       "%d buddies were added or updated from the server (including buddies already on the server-side list)",
-						       buddy_count),
-					      buddy_count);
-			purple_notify_info(session->account, _("Add contacts from server"), msg, NULL);
-			g_free(msg);
-			break;
-		case MSIM_CONTACT_LIST_IMPORT_TOP_FRIENDS:
-			/* TODO */
-			break;
-		case MSIM_CONTACT_LIST_INITIAL_FRIENDS:
-			/* Nothing */
-			break;
-	}
-	msim_msg_free(body);
-}
-/* Get contact list, calling msim_got_contact_list() with what_to_do_after as user_data gpointer. */
-static gboolean
-msim_get_contact_list(MsimSession *session, int what_to_do_after)
-{
-	return msim_send(session,
 			"persist", MSIM_TYPE_INTEGER, 1,
 			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_GET,
+			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_BIT_ACTION | MSIM_CMD_DELETE,
-			"dsn", MSIM_TYPE_INTEGER, MG_LIST_ALL_CONTACTS_DSN,
+			"dsn", MSIM_TYPE_INTEGER, MD_DELETE_BUDDY_DSN,
-			"lid", MSIM_TYPE_INTEGER, MG_LIST_ALL_CONTACTS_LID,
+			"lid", MSIM_TYPE_INTEGER, MD_DELETE_BUDDY_LID,
 			"uid", MSIM_TYPE_INTEGER, session->userid,
-			"rid", MSIM_TYPE_INTEGER,
+			"rid", MSIM_TYPE_INTEGER, session->next_rid++,
-				msim_new_reply_callback(session, msim_got_contact_list, GUINT_TO_POINTER(what_to_do_after)),
+			/* <uid> will be replaced by postprocessing */
-			"body", MSIM_TYPE_STRING, g_strdup(""),
+			"body", MSIM_TYPE_STRING, g_strdup("ContactID=<uid>"),
 			NULL);
-}
+	if (!msim_postprocess_outgoing(session, persist_msg, buddy->name, "body", NULL)) {
+		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("persist command failed"));
-/** Called when friends have been imported to buddy list on server. */
+		msim_msg_free(persist_msg);
-static void
-msim_import_friends_cb(MsimSession *session, MsimMessage *reply, gpointer user_data)
-{
-	MsimMessage *body;
-	gchar *completed;
-	msim_msg_dump("msim_import_friends_cb=%s", reply);
-	/* Check if the friends were imported successfully. */
-	body = msim_msg_get_dictionary(reply, "body");
-	g_return_if_fail(body != NULL);
-	completed = msim_msg_get_string(body, "Completed");
-	g_return_if_fail(body != NULL);
-	msim_msg_free(body);
-	if (!g_str_equal(completed, "True"))
-	{
-		purple_debug_info("msim_import_friends_cb",
-				"failed to import friends: %s", completed);
-		purple_notify_error(session->account, _("Add friends from MySpace.com"),
-				_("Importing friends failed"), NULL);
-		g_free(completed);
 		return;
 	}
-	g_free(completed);
+	msim_msg_free(persist_msg);
-	purple_debug_info("msim_import_friends_cb",
+	blocklist_updates = NULL;
-			"added friends to server-side buddy list, requesting new contacts from server");
+	blocklist_updates = g_list_prepend(blocklist_updates, "a-");
+	blocklist_updates = g_list_prepend(blocklist_updates, "<uid>");
-	msim_get_contact_list(session, MSIM_CONTACT_LIST_IMPORT_ALL_FRIENDS);
+	blocklist_updates = g_list_prepend(blocklist_updates, "b-");
+	blocklist_updates = g_list_prepend(blocklist_updates, "<uid>");
-	/* TODO: show, X friends have been added */
+	blocklist_updates = g_list_reverse(blocklist_updates);
-}
+	blocklist_msg = msim_msg_new(
-/** Import friends from myspace.com. */
+			"blocklist", MSIM_TYPE_BOOLEAN, TRUE,
-static void msim_import_friends(PurplePluginAction *action)
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
-{
+			/* TODO: MsimMessage lists. Currently <uid> isn't replaced in lists. */
-	PurpleConnection *gc;
+			/* "idlist", MSIM_TYPE_STRING, g_strdup("a-|<uid>|b-|<uid>"), */
+			"idlist", MSIM_TYPE_LIST, blocklist_updates,
+			NULL);
+	if (!msim_postprocess_outgoing(session, blocklist_msg, buddy->name, "idlist", NULL)) {
+		purple_notify_error(NULL, NULL, _("Failed to remove buddy"), _("blocklist command failed"));
+		msim_msg_free(blocklist_msg);
+		return;
+	}
+	msim_msg_free(blocklist_msg);
+}
+/**
+* Returns a string of a username in canonical form. Basically removes all the
+* spaces, lowercases the string, and looks up user IDs to usernames.
+* Normalizing tom, TOM, Tom, and 6221 wil all return 'tom'.
+*
+* Borrowed this code from oscar_normalize. Added checking for
+* "if userid, get name before normalizing"
+*/
+static const char *msim_normalize(const PurpleAccount *account, const char *str) {
+	static char normalized[BUF_LEN];
+	char *tmp1, *tmp2;
+	int i, j;
+	guint id;
+	g_return_val_if_fail(str != NULL, NULL);
+	if (msim_is_userid(str)) {
+		/* Have user ID, we need to get their username first :) */
+		const char *username;
+		/* If the account does not exist, we can't look up the user. */
+		if (!account || !account->gc)
+			return str;
+		id = atol(str);
+		username = msim_uid2username_from_blist((PurpleAccount *)account, id);
+		if (!username) {
+			/* Not in buddy list... scheisse... TODO: Manual Lookup! Bug #4631 */
+			/* Note: manual lookup using msim_lookup_user() is a problem inside
+			 * msim_normalize(), because msim_lookup_user() calls a callback function
+			 * when the user information has been looked up, but msim_normalize() expects
+			 * the result immediately. */
+			strncpy(normalized, str, BUF_LEN);
+		} else {
+			strncpy(normalized, username, BUF_LEN);
+		}
+	} else {
+		/* Have username. */
+		strncpy(normalized, str, BUF_LEN);
+	}
+	/* Strip spaces. */
+	for (i=0, j=0; normalized[j]; i++, j++) {
+		while (normalized[j] == ' ')
+			j++;
+		normalized[i] = normalized[j];
+	}
+	normalized[i] = '\0';
+	/* Lowercase and perform UTF-8 normalization. */
+	tmp1 = g_utf8_strdown(normalized, -1);
+	tmp2 = g_utf8_normalize(tmp1, -1, G_NORMALIZE_DEFAULT);
+	g_snprintf(normalized, sizeof(normalized), "%s", tmp2);
+	g_free(tmp2);
+	g_free(tmp1);
+	/* TODO: re-add caps and spacing back to what the user wanted.
+	 * User can format their own names, for example 'msimprpl' is shown
+	 * as 'MsIm PrPl' in the official client.
+	 *
+	 * TODO: file a ticket to add this enhancement.
+	 */
+	return normalized;
+}
+/**
+* Return whether the buddy can be messaged while offline.
+*
+* The protocol supports offline messages in just the same way as online
+* messages.
+*/
+static gboolean
+msim_offline_message(const PurpleBuddy *buddy)
+{
+	return TRUE;
+}
+/**
+* Send raw data to the server, possibly with embedded NULs.
+*
+* Used in prpl_info struct, so that plugins can have the most possible
+* control of what is sent over the connection. Inside this prpl,
+* msim_send_raw() is used, since it sends NUL-terminated strings (easier).
+*
+* @param gc PurpleConnection
+* @param buf Buffer to send
+* @param total_bytes Size of buffer to send
+*
+* @return Bytes successfully sent, or -1 on error.
+*/
+static int
+msim_send_really_raw(PurpleConnection *gc, const char *buf, int total_bytes)
+{
+	int total_bytes_sent;
 	MsimSession *session;
-	gchar *group_name;
+	g_return_val_if_fail(gc != NULL, -1);
-	gc = (PurpleConnection *)action->context;
+	g_return_val_if_fail(buf != NULL, -1);
+	g_return_val_if_fail(total_bytes >= 0, -1);
 	session = (MsimSession *)gc->proto_data;
-	group_name = "MySpace Friends";
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
-	g_return_if_fail(msim_send(session,
+	/* Loop until all data is sent, or a failure occurs. */
-			"persist", MSIM_TYPE_INTEGER, 1,
+	total_bytes_sent = 0;
-			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+	do {
-			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_PUT,
+		int bytes_sent;
-			"dsn", MSIM_TYPE_INTEGER, MC_IMPORT_ALL_FRIENDS_DSN,
-			"lid", MSIM_TYPE_INTEGER, MC_IMPORT_ALL_FRIENDS_LID,
+		bytes_sent = send(session->fd, buf + total_bytes_sent,
-			"uid", MSIM_TYPE_INTEGER, session->userid,
+				total_bytes - total_bytes_sent, 0);
-			"rid", MSIM_TYPE_INTEGER,
-				msim_new_reply_callback(session, msim_import_friends_cb, NULL),
+		if (bytes_sent < 0) {
-			"body", MSIM_TYPE_STRING,
+			purple_debug_info("msim", "msim_send_raw(%s): send() failed: %s\n",
-				g_strdup_printf("GroupName=%s", group_name),
+					buf, g_strerror(errno));
-			NULL));
+			return total_bytes_sent;
+		}
+		total_bytes_sent += bytes_sent;
-}
+	} while(total_bytes_sent < total_bytes);
-/** Actions menu for account. */
-GList *
+	return total_bytes_sent;
-msim_actions(PurplePlugin *plugin, gpointer context)
+}
-{
-	PurpleConnection *gc;
+/**
-	GList *menu;
+* Send raw data (given as a NUL-terminated string) to the server.
-	PurplePluginAction *act;
+*
+* @param session
-	gc = (PurpleConnection *)context;
+* @param msg The raw data to send, in a NUL-terminated string.
+*
-	menu = NULL;
+* @return TRUE if succeeded, FALSE if not.
+*
-#if 0
+*/
-	/* TODO: find out how */
+gboolean
-	act = purple_plugin_action_new(_("Find people..."), msim_);
+msim_send_raw(MsimSession *session, const gchar *msg)
-	menu = g_list_append(menu, act);
+{
+	size_t len;
-	act = purple_plugin_action_new(_("Change IM name..."), NULL);
-	menu = g_list_append(menu, act);
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
-#endif
+	g_return_val_if_fail(msg != NULL, FALSE);
-	act = purple_plugin_action_new(_("Add friends from MySpace.com"), msim_import_friends);
+	purple_debug_info("msim", "msim_send_raw: writing <%s>\n", msg);
-	menu = g_list_append(menu, act);
+	len = strlen(msg);
-	return menu;
+	return msim_send_really_raw(session->gc, msg, len) == len;
 }
-/** Callbacks called by Purple, to access this plugin. */
+static GHashTable *
+msim_get_account_text_table(PurpleAccount *unused)
+{
+	GHashTable *table;
+	table = g_hash_table_new(g_str_hash, g_str_equal);
+	g_hash_table_insert(table, "login_label", (gpointer)_("Email Address..."));
+	return table;
+}
+/**
+* Callbacks called by Purple, to access this plugin.
+*/
 static PurplePluginProtocolInfo prpl_info = {
 	/* options */
 	  OPT_PROTO_USE_POINTSIZE        /* specify font size in sane point size */
 	| OPT_PROTO_MAIL_CHECK,
 	/* | OPT_PROTO_IM_IMAGE - TODO: direct images. */
 	NULL,              /* user_splits */
 	NULL,              /* protocol_options */
 	NO_BUDDY_ICONS,    /* icon_spec - TODO: eventually should add this */
 	msim_list_icon,    /* list_icon */
 	NULL,              /* list_emblems */
 	sizeof(PurplePluginProtocolInfo),  /* struct_size */
 	msim_get_account_text_table,              /* get_account_text_table */
 };
+/**
+* Load the plugin.
-/** Based on MSN's plugin info comments. */
+*/
+static gboolean
+msim_load(PurplePlugin *plugin)
+{
+	/* If compiled to use RC4 from libpurple, check if it is really there. */
+	if (!purple_ciphers_find_cipher("rc4")) {
+		purple_debug_error("msim", "rc4 not in libpurple, but it is required - not loading MySpaceIM plugin!\n");
+		purple_notify_error(plugin, _("Missing Cipher"),
+				_("The RC4 cipher could not be found"),
+				_("Upgrade "
+					"to a libpurple with RC4 support (>= 2.0.1). MySpaceIM "
+					"plugin will not be loaded."));
+		return FALSE;
+	}
+	return TRUE;
+}
+/**
+* Called when friends have been imported to buddy list on server.
+*/
+static void
+msim_import_friends_cb(MsimSession *session, MsimMessage *reply, gpointer user_data)
+{
+	MsimMessage *body;
+	gchar *completed;
+	msim_msg_dump("msim_import_friends_cb=%s", reply);
+	/* Check if the friends were imported successfully. */
+	body = msim_msg_get_dictionary(reply, "body");
+	g_return_if_fail(body != NULL);
+	completed = msim_msg_get_string(body, "Completed");
+	g_return_if_fail(body != NULL);
+	msim_msg_free(body);
+	if (!g_str_equal(completed, "True"))
+	{
+		purple_debug_info("msim_import_friends_cb",
+				"failed to import friends: %s", completed);
+		purple_notify_error(session->account, _("Add friends from MySpace.com"),
+				_("Importing friends failed"), NULL);
+		g_free(completed);
+		return;
+	}
+	g_free(completed);
+	purple_debug_info("msim_import_friends_cb",
+			"added friends to server-side buddy list, requesting new contacts from server");
+	msim_get_contact_list(session, MSIM_CONTACT_LIST_IMPORT_ALL_FRIENDS);
+	/* TODO: show, X friends have been added */
+}
+/**
+* Import friends from myspace.com.
+*/
+static void msim_import_friends(PurplePluginAction *action)
+{
+	PurpleConnection *gc;
+	MsimSession *session;
+	gchar *group_name;
+	gc = (PurpleConnection *)action->context;
+	session = (MsimSession *)gc->proto_data;
+	group_name = "MySpace Friends";
+	g_return_if_fail(msim_send(session,
+			"persist", MSIM_TYPE_INTEGER, 1,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"cmd", MSIM_TYPE_INTEGER, MSIM_CMD_PUT,
+			"dsn", MSIM_TYPE_INTEGER, MC_IMPORT_ALL_FRIENDS_DSN,
+			"lid", MSIM_TYPE_INTEGER, MC_IMPORT_ALL_FRIENDS_LID,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"rid", MSIM_TYPE_INTEGER,
+				msim_new_reply_callback(session, msim_import_friends_cb, NULL),
+			"body", MSIM_TYPE_STRING,
+				g_strdup_printf("GroupName=%s", group_name),
+			NULL));
+}
+/**
+* Actions menu for account.
+*/
+static GList *
+msim_actions(PurplePlugin *plugin, gpointer context)
+{
+	PurpleConnection *gc;
+	GList *menu;
+	PurplePluginAction *act;
+	gc = (PurpleConnection *)context;
+	menu = NULL;
+#if 0
+	/* TODO: find out how */
+	act = purple_plugin_action_new(_("Find people..."), msim_);
+	menu = g_list_append(menu, act);
+	act = purple_plugin_action_new(_("Change IM name..."), NULL);
+	menu = g_list_append(menu, act);
+#endif
+	act = purple_plugin_action_new(_("Add friends from MySpace.com"), msim_import_friends);
+	menu = g_list_append(menu, act);
+	return menu;
+}
+/**
+* Based on MSN's plugin info comments.
+*/
 static PurplePluginInfo info = {
 	PURPLE_PLUGIN_MAGIC,
 	PURPLE_MAJOR_VERSION,
 	PURPLE_MINOR_VERSION,
 	PURPLE_PLUGIN_PROTOCOL,                           /**< type           */
 	NULL,                                             /**< reserved2      */
 	NULL,                                             /**< reserved3      */
 	NULL                                              /**< reserved4      */
 };
 #ifdef MSIM_SELF_TEST
-/** Test functions.
+/*
+* Test functions.
 * Used to test or try out the internal workings of msimprpl. If you're reading
 * this code for the first time, these functions can be instructive in learning
 * how msimprpl is architected.
 */
-void
-msim_test_all(void) {
+/**
-	guint failures;
+* Test MsimMessage for basic functionality.
+*/
+static int
-	failures = 0;
-	failures += msim_test_msg();
-	failures += msim_test_escaping();
-	if (failures) {
-		purple_debug_info("msim", "msim_test_all HAD FAILURES: %d\n", failures);
-	} else {
-		purple_debug_info("msim", "msim_test_all - all tests passed!\n");
-	}
-	exit(0);
-}
-/** Test MsimMessage for basic functionality. */
-int
 msim_test_msg(void)
 {
 	MsimMessage *msg, *msg_cloned, *msg2;
 	GList *list;
 	gchar *packed, *packed_expected, *packed_cloned;
 	msim_msg_free(msg2);
 	return failures;
 }
-/** Test protocol-level escaping/unescaping. */
+/**
-int
+* Test protocol-level escaping/unescaping.
+*/
+static int
 msim_test_escaping(void)
 {
 	guint failures;
 	gchar *raw, *escaped, *unescaped, *expected;
 				++failures, raw, unescaped);
 	}
 	return failures;
 }
+static void
+msim_test_all(void)
+{
+	guint failures;
+	failures = 0;
+	failures += msim_test_msg();
+	failures += msim_test_escaping();
+	if (failures) {
+		purple_debug_info("msim", "msim_test_all HAD FAILURES: %d\n", failures);
+	} else {
+		purple_debug_info("msim", "msim_test_all - all tests passed!\n");
+	}
+	exit(0);
+}
 #endif
+#ifdef MSIM_CHECK_NEWER_VERSION
+/**
+* Callback for when a currentversion.txt has been downloaded.
+*/
+static void
+msim_check_newer_version_cb(PurpleUtilFetchUrlData *url_data,
+		gpointer user_data,
+		const gchar *url_text,
+		gsize len,
+		const gchar *error_message)
+{
+	GKeyFile *keyfile;
+	GError *error;
+	GString *data;
+	gchar *newest_filever;
+	if (!url_text) {
+		purple_debug_info("msim_check_newer_version_cb",
+				"got error: %s\n", error_message);
+		return;
+	}
+	purple_debug_info("msim_check_newer_version_cb",
+			"url_text=%s\n", url_text ? url_text : "(NULL)");
+	/* Prepend [group] so that GKeyFile can parse it (requires a group). */
+	data = g_string_new(url_text);
+	purple_debug_info("msim", "data=%s\n", data->str
+			? data->str : "(NULL)");
+	data = g_string_prepend(data, "[group]\n");
+	purple_debug_info("msim", "data=%s\n", data->str
+			? data->str : "(NULL)");
+	/* url_text is variable=data\n...†*/
+	/* Check FILEVER, 1.0.716.0. 716 is build, MSIM_CLIENT_VERSION */
+	/* New (english) version can be downloaded from SETUPURL+SETUPFILE */
+	error = NULL;
+	keyfile = g_key_file_new();
+	/* Default list seperator is ;, but currentversion.txt doesn't have
+	 * these, so set to an unused character to avoid parsing problems. */
+	g_key_file_set_list_separator(keyfile, '\0');
+	g_key_file_load_from_data(keyfile, data->str, data->len,
+				G_KEY_FILE_NONE, &error);
+	g_string_free(data, TRUE);
+	if (error != NULL) {
+		purple_debug_info("msim_check_newer_version_cb",
+				"couldn't parse, error: %d %d %s\n",
+				error->domain, error->code, error->message);
+		g_error_free(error);
+		return;
+	}
+	gchar **ks;
+	guint n;
+	ks = g_key_file_get_keys(keyfile, "group", &n, NULL);
+	purple_debug_info("msim", "n=%d\n", n);
+	guint i;
+	for (i = 0; ks[i] != NULL; ++i)
+	{
+		purple_debug_info("msim", "%d=%s\n", i, ks[i]);
+	}
+	newest_filever = g_key_file_get_string(keyfile, "group",
+			"FILEVER", &error);
+	purple_debug_info("msim_check_newer_version_cb",
+			"newest filever: %s\n", newest_filever ?
+			newest_filever : "(NULL)");
+	if (error != NULL) {
+		purple_debug_info("msim_check_newer_version_cb",
+				"error: %d %d %s\n",
+				error->domain, error->code, error->message);
+		g_error_free(error);
+	}
+	g_key_file_free(keyfile);
+	exit(0);
+}
+#endif
+/**
+Handle a myim:addContact command, after username has been looked up.
+*/
+static void
+msim_uri_handler_addContact_cb(MsimSession *session, MsimMessage *userinfo, gpointer data)
+{
+	MsimMessage *body;
+	gchar *username;
+	body = msim_msg_get_dictionary(userinfo, "body");
+	username = msim_msg_get_string(body, "UserName");
+	msim_msg_free(body);
+	if (!username) {
+		guint uid;
+		uid = msim_msg_get_integer(userinfo, "UserID");
+		g_return_if_fail(uid != 0);
+		username = g_strdup_printf("%d", uid);
+	}
+	purple_blist_request_add_buddy(session->account, username, _("Buddies"), NULL);
+	g_free(username);
+}
+/* TODO: move uid->username resolving to IM sending and buddy adding functions,
+* so that user can manually add or IM by userid and username automatically
+* looked up if possible? */
+/**
+* Handle a myim:sendIM URI command, after username has been looked up.
+*/
+static void
+msim_uri_handler_sendIM_cb(MsimSession *session, MsimMessage *userinfo, gpointer data)
+{
+	PurpleConversation *conv;
+	MsimMessage *body;
+	gchar *username;
+	body = msim_msg_get_dictionary(userinfo, "body");
+	username = msim_msg_get_string(body, "UserName");
+	msim_msg_free(body);
+	if (!username) {
+		guint uid;
+		uid = msim_msg_get_integer(userinfo, "UserID");
+		g_return_if_fail(uid != 0);
+		username = g_strdup_printf("%d", uid);
+	}
+	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, username, session->account);
+	if (!conv)  {
+		purple_debug_info("msim_uri_handler", "creating new conversation for %s\n", username);
+		conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, session->account, username);
+	}
+	/* Just open the window so the user can send an IM. */
+	purple_conversation_present(conv);
+	g_free(username);
+}
 static gboolean
 msim_uri_handler(const gchar *proto, const gchar *cmd, GHashTable *params)
 {
 	PurpleAccount *account;
 	/* TODO: if auto=true, "Add all the people on this page to my IM List!", on
 	 * http://collect.myspace.com/index.cfm?fuseaction=im.friendslist. Don't need a cid. */
 	/* Convert numeric contact ID back to a string. Needed for looking up. Don't just
 	 * directly use cid directly from parameters, because it might not be numeric.
 	 * It is trivial to change this to allow cID to be a username, but that's not how
 	 * the official MySpaceIM client works, so don't provide that functionality. */
 	cid_str = g_strdup_printf("%d", cid);
 		}
 		l = l->next;
 	}
 	if (!account) {
 		purple_notify_error(NULL, _("myim URL handler"),
 				_("No suitable MySpaceIM account could be found to open this myim URL."),
 				_("Enable the proper MySpaceIM account and try again."));
 		g_free(cid_str);
 		return FALSE;
 	}
 	session = (MsimSession *)account->gc->proto_data;
 	g_return_val_if_fail(session != NULL, FALSE);
 	/* Lookup userid to username. TODO: push this down, to IM sending/contact
 	 * adding functions. */
 	/* myim:sendIM?uID=USERID&cID=CONTACTID */
 	if (!g_ascii_strcasecmp(cmd, "sendIM")) {
 		msim_lookup_user(session, cid_str, (MSIM_USER_LOOKUP_CB)msim_uri_handler_sendIM_cb, NULL);
 	}
 	return FALSE;
 }
-/* TODO: move uid->username resolving to IM sending and buddy adding functions,
+#ifdef MSIM_DEBUG_MSG
-* so that user can manually add or IM by userid and username automatically
-* looked up if possible? */
-/** Handle a myim:sendIM URI command, after username has been looked up. */
 static void
-msim_uri_handler_sendIM_cb(MsimSession *session, MsimMessage *userinfo, gpointer data)
+print_hash_item(gpointer key, gpointer value, gpointer user_data)
 {
-	PurpleConversation *conv;
+	purple_debug_info("msim", "%s=%s\n",
-	MsimMessage *body;
+			key ? (gchar *)key : "(NULL)",
-	gchar *username;
+			value ? (gchar *)value : "(NULL)");
+}
-	body = msim_msg_get_dictionary(userinfo, "body");
+#endif
-	username = msim_msg_get_string(body, "UserName");
-	msim_msg_free(body);
+/**
+* Initialize plugin.
-	if (!username) {
+*/
-		guint uid;
-		uid = msim_msg_get_integer(userinfo, "UserID");
-		g_return_if_fail(uid != 0);
-		username = g_strdup_printf("%d", uid);
-	}
-	conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, username, session->account);
-	if (!conv)  {
-		purple_debug_info("msim_uri_handler", "creating new conversation for %s\n", username);
-		conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, session->account, username);
-	}
-	/* Just open the window so the user can send an IM. */
-	purple_conversation_present(conv);
-	g_free(username);
-}
-/** Handle a myim:addContact command, after username has been looked up. */
 static void
-msim_uri_handler_addContact_cb(MsimSession *session, MsimMessage *userinfo, gpointer data)
+init_plugin(PurplePlugin *plugin)
-{
-	MsimMessage *body;
-	gchar *username;
-	body = msim_msg_get_dictionary(userinfo, "body");
-	username = msim_msg_get_string(body, "UserName");
-	msim_msg_free(body);
-	if (!username) {
-		guint uid;
-		uid = msim_msg_get_integer(userinfo, "UserID");
-		g_return_if_fail(uid != 0);
-		username = g_strdup_printf("%d", uid);
-	}
-	purple_blist_request_add_buddy(session->account, username, _("Buddies"), NULL);
-	g_free(username);
-}
-/** Initialize plugin. */
-void
-init_plugin(PurplePlugin *plugin)
 {
 #ifdef MSIM_SELF_TEST
 	msim_test_all();
 	exit(0);
 #endif /* MSIM_SELF_TEST */
 	option = purple_account_option_int_new(_("Base font size (points)"), "base_font_size", MSIM_BASE_FONT_POINT_SIZE);
 	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
 #endif
 	/* Code below only runs once. Based on oscar.c's oscar_init(). */
 	if (initialized)
 		return;
 	initialized = TRUE;
 	purple_signal_connect(purple_get_core(), "uri-handler", &initialized,

Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/myspace/myspace.c

libpurple/protocols/myspace/myspace.c