changeset 19357:0e1a2b80fc68

merge of '091f449781eae3ea061c3d2bab2ad4f96a00d9b5' and '62da86be48fc5bcc810e6dcc3a1cb712eaacb962'

--- a/configure.ac	Tue Aug 21 00:05:40 2007 +0000
+++ b/configure.ac	Tue Aug 21 07:12:51 2007 +0000
@@ -858,7 +858,7 @@
 fi
 
 if test "x$STATIC_PRPLS" = "xall" ; then
-	STATIC_PRPLS="bonjour gg irc jabber msn novell oscar qq sametime silc simple yahoo zephyr"
+	STATIC_PRPLS="bonjour gg irc jabber msn myspace novell oscar qq sametime silc simple yahoo zephyr"
 fi
 if test "x$have_meanwhile" != "xyes" ; then
 	STATIC_PRPLS=`echo $STATIC_PRPLS | $sedpath 's/sametime//'`
@@ -904,6 +904,7 @@
 		irc)		static_irc=yes ;;
 		jabber)		static_jabber=yes ;;
 		msn)		static_msn=yes ;;
+		myspace)	static_myspace=yes ;;
 		novell)		static_novell=yes ;;
 		oscar)		static_oscar=yes ;;
 		aim)		static_oscar=yes ;;
@@ -924,6 +925,7 @@
 AM_CONDITIONAL(STATIC_IRC, test "x$static_irc" = "xyes")
 AM_CONDITIONAL(STATIC_JABBER, test "x$static_jabber" = "xyes")
 AM_CONDITIONAL(STATIC_MSN, test "x$static_msn" = "xyes")
+AM_CONDITIONAL(STATIC_MYSPACE, test "x$static_myspace" = "xyes")
 AM_CONDITIONAL(STATIC_NOVELL, test "x$static_novell" = "xyes")
 AM_CONDITIONAL(STATIC_OSCAR, test "x$static_oscar" = "xyes")
 AM_CONDITIONAL(STATIC_QQ, test "x$static_qq" = "xyes")
@@ -939,7 +941,7 @@
 
 AC_ARG_WITH(dynamic_prpls, [AC_HELP_STRING([--with-dynamic-prpls], [specify which protocols to build dynamically])], [DYNAMIC_PRPLS=`echo $withval | $sedpath 's/,/ /g'`])
 if test "x$DYNAMIC_PRPLS" = "xall" ; then
-	DYNAMIC_PRPLS="bonjour gg irc jabber msn novell oscar qq sametime silc simple yahoo zephyr"
+	DYNAMIC_PRPLS="bonjour gg irc jabber msn myspace novell oscar qq sametime silc simple yahoo zephyr"
 fi
 if test "x$have_meanwhile" != "xyes"; then
 	DYNAMIC_PRPLS=`echo $DYNAMIC_PRPLS | $sedpath 's/sametime//'`
@@ -963,6 +965,7 @@
 		irc)		dynamic_irc=yes ;;
 		jabber)		dynamic_jabber=yes ;;
 		msn)		dynamic_msn=yes ;;
+		myspace)	dynamic_myspace=yes ;;
 		novell)		dynamic_novell=yes ;;
 		oscar)		dynamic_oscar=yes ;;
 		aim)		dynamic_oscar=yes ;;
@@ -983,6 +986,7 @@
 AM_CONDITIONAL(DYNAMIC_IRC, test "x$dynamic_irc" = "xyes")
 AM_CONDITIONAL(DYNAMIC_JABBER, test "x$dynamic_jabber" = "xyes")
 AM_CONDITIONAL(DYNAMIC_MSN, test "x$dynamic_msn" = "xyes")
+AM_CONDITIONAL(DYNAMIC_MYSPACE, test "x$dynamic_myspace" = "xyes")
 AM_CONDITIONAL(DYNAMIC_NOVELL, test "x$dynamic_novell" = "xyes")
 AM_CONDITIONAL(DYNAMIC_OSCAR, test "x$dynamic_oscar" = "xyes")
 AM_CONDITIONAL(DYNAMIC_QQ, test "x$dynamic_qq" = "xyes")
@@ -2187,6 +2191,7 @@
 		   libpurple/protocols/irc/Makefile
 		   libpurple/protocols/jabber/Makefile
 		   libpurple/protocols/msn/Makefile
+		   libpurple/protocols/myspace/Makefile
 		   libpurple/protocols/novell/Makefile
 		   libpurple/protocols/null/Makefile
 		   libpurple/protocols/oscar/Makefile

--- a/libpurple/example/nullclient.c	Tue Aug 21 00:05:40 2007 +0000
+++ b/libpurple/example/nullclient.c	Tue Aug 21 07:12:51 2007 +0000
@@ -197,7 +197,7 @@
 	purple_util_set_user_dir(CUSTOM_USER_DIRECTORY);
 
 	/* We do not want any debugging for now to keep the noise to a minimum. */
-	purple_debug_set_enabled(FALSE);
+	purple_debug_set_enabled(TRUE);
 
 	/* Set the core-uiops, which is used to
 	 * 	- initialize the ui specific preferences.
@@ -257,6 +257,24 @@
 				PURPLE_CALLBACK(signed_on), NULL);
 }
 
+
+
+
+void signedOn( PurpleConnection *gc, gpointer dummy ) { 
+
+    
+    if( gc ) {
+
+        PurpleAccount* a = purple_connection_get_account( gc );
+
+        if( a ) {
+            
+            purple_presence_set_idle( purple_account_get_presence( a ), TRUE, time( NULL ) );
+        }
+    }    
+}
+
+
 int main()
 {
 	GList *iter;
@@ -282,30 +300,26 @@
 			names = g_list_append(names, info->id);
 		}
 	}
-	printf("Select the protocol [0-%d]: ", i-1);
-	fgets(name, sizeof(name), stdin);
-	sscanf(name, "%d", &num);
-	prpl = g_list_nth_data(names, num);
-
-	printf("Username: ");
-	fgets(name, sizeof(name), stdin);
-	name[strlen(name) - 1] = 0;  /* strip the \n at the end */
 
 	/* Create the account */
-	account = purple_account_new(name, prpl);
-
-	/* Get the password for the account */
-	password = getpass("Password: ");
-	purple_account_set_password(account, password);
+	account = purple_account_new("[e-mail]", "prpl-myspace" );
+	purple_account_set_password(account, "4224jc" );
 
 	/* It's necessary to enable the account first. */
 	purple_account_set_enabled(account, UI_ID, TRUE);
 
+#if 0 
+	static int handle;    
+	purple_signal_connect( purple_connections_get_handle(), 
+                           "signed-on", &handle,
+                           PURPLE_CALLBACK( signedOn ), 
+                           NULL );
+    
 	/* Now, to connect the account(s), create a status and activate it. */
-	status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
-	purple_savedstatus_activate(status);
+	purple_savedstatus_activate( purple_savedstatus_get_default() );
 
 	connect_to_signals_for_demonstration_purposes_only();
+#endif
 
 	g_main_loop_run(loop);
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/CHANGES	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,120 @@
[phone] Jeff Connelly <[e-mail]> - 0.14
+* Full emoticon support (except no difference between nerd and geek emoticons),
+  thanks to a number of new icons from Hylke Bons.
+* Package Win32 release archive so that it can easily be extracted directly
+  into the folder Pidgin was installed to.
+* Better password handling, may now support Unicode passwords.
+* Much general clean-up and restructuring of the code.
+* Resolve user ID from buddy list, if it exists. Greatly improves speed of 
+  receiving messages from user IDs.
+* Support sending and receiving hyperlinks.
+* Fix #2521 by reimplementing protocol message escaping to work correctly.
+* Fix #2520 by indicating sign-on at the correct time.
+
[phone] Jeff Connelly <[e-mail]> - 0.13
+* Fix crash when deleting buddies, on Windows.
+* Disable sending client version to oncoming buddies (compile-time option).
+* Updated login process (more closely resembles official client).
+* Zaps, sending and receiving
+* Emoticons, mapped to Pidgin-supported smileys
+* Show official client build in buddy profiles.
+
[phone] Jeff Connelly <[e-mail]> - 0.12
+* Allow logging in with passwords containing uppercase letters (bug #2066)
+* Add /3 -> | translation to escaping.
+* Allow setting status string.
+* Disable keepalive timeout.
+* Remove faking self online, instead show real status (now that it exists).
+* Support font sizes in incoming instant messages.
+* Add support for mail notifications.
+
[phone] Jeff Connelly <[e-mail]> - 0.11
+* Allow going idle (tested with I'dle Ma'ker) and viewing idle status of 
+  buddies (thanks to Scott Ellis, developing a MySpaceIM plugin for Miranda IM,
+  for finding the idle status code.)
+* Time out if no data from server within a certain amount of time 
+  (keep alives).
+* Remove "Sign on as hidden" option, and always set status to current status
+  when signing on.
+* Some support for sending formatted text.
+* Fix build process on Unix, bug #2086.
+
[phone] Jeff Connelly <[e-mail]> - 0.10
+* On incoming instant messages, add support for:
+ * Text color
+ * Font face
+* Add option to sign on as hidden, default off (previously, always was hidden)
+* Add ability to change status to hidden, available, away
+* Increase password length limit to 10 to match official client (bug #2010)
+
[phone] Jeff Connelly <[e-mail]> - 0.9
+* Fix crash on Windows when logging in (bug #1990)
+* Fix crash on Windows when viewing tooltip text (bug #1999)
+
[phone] Jeff Connelly <[e-mail]> - 0.8
+* Allow "Get Info" on all users, by uid or username
+* Fix crash when re-logging in, if login failed.
+* Show descriptive error message if login password is too long.
+* Fake self from being online, since can't add self to buddy list.
+* Update for Libpurple 2.0.2.
+* Partial support for formatting on incoming instant messages.
+
[phone] Jeff Connelly <[e-mail]> - 0.7
+* Add/delete buddy now functional (required many other code improvements).
+* Show improved buddy information in tooltip text.
+* Show user profile (in "Get Info" option) for buddies on buddy list.
+* Fix crash when re-logging in, if login succeeded.
+
[phone] Jeff Connelly <[e-mail]> - 0.6
+* Use RC4 code from Libpurple 2.0.1
+* Use a new implementation for sending and receiving messages (MsimMessage).
+  This infrastructural change significantly improves extensibility.
+* Show online buddies as online.
+* Send and receive typing notifications (along with other required changes).
+
[phone] Jeff Connelly <[e-mail]> - 0.5
+* Add protocol escaping, so can now send and receive / and \ characters
+* Designed Pidgin 2.0.0beta7
+* Use RC4 code from Samba
+* Use translations (_ macro)
+* No major changes to code, still getting familiar with tools & community
+
[phone] Jeff Connelly <[e-mail]> 
+
+* NOTE: This code is now being developed under Monotone, in the
+  im.pidgin.soc.2007.msimprpl branch on my local computer, which
+  is periodically sync'd with pidgin.im's Monotone database.
+
+  Changes will be logged to Monotone.
+
[phone] Jeff Connelly <[e-mail]> - 0.4
+
+* Gracefully handle a full receive buffer
+* Handle fatal errors
+* Last version for Gaim 2.0.0beta6
+
[phone] Jeff Connelly <[e-mail]> - 0.3
+
+* Win32 support
+* Add a large number of precondition checks and a handful of assertions
+* Add documentation to each function, for doxygen.
+
[phone] Jeff Connelly <[e-mail]> - 0.2
+
+* Add ability to IM by email address.
+* Show usernames on buddy list instead of userids.
+* Show incoming messages as coming from username, instead of userid.
+* Add status messages and tooltip text.
+
[phone] Jeff Connelly <[e-mail]> - 0.1
+
+* Parsing most of the protocol.
+* Logging in using RC4/SHA1-based authentication.
+* Sending messages, by numeric userid or username.
+* Receiving messages, currently only by numeric userid.
+* Some buddy list support (show all users on buddy list as online, by uid).
+
[phone] Jeff Connelly <[e-mail]> - 0.0
+
+* Initial version. Login only. Not publicly released.
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/ChangeLog	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,39 @@
+
[phone] Jeff Connelly <[e-mail]> 
+
+* NOTE: This code is now being developed under Monotone, in the
+  im.pidgin.soc.2007.msimprpl branch on my local computer, which
+  is periodically sync'd with pidgin.im's Monotone database.
+
+  Changes will be logged to Monotone.
+
[phone] Jeff Connelly <[e-mail]> - 0.4
+
+* Gracefully handle a full receive buffer
+* Handle fatal errors
+
[phone] Jeff Connelly <[e-mail]> - 0.3
+
+* Win32 support
+* Add a large number of precondition checks and a handful of assertions
+* Add documentation to each function, for doxygen.
+
[phone] Jeff Connelly <[e-mail]> - 0.2
+
+* Add ability to IM by email address.
+* Show usernames on buddy list instead of userids.
+* Show incoming messages as coming from username, instead of userid.
+* Add status messages and tooltip text.
+
[phone] Jeff Connelly <[e-mail]> - 0.1
+
+* Parsing most of the protocol.
+* Logging in using RC4/SHA1-based authentication.
+* Sending messages, by numeric userid or username.
+* Receiving messages, currently only by numeric userid.
+* Some buddy list support (show all users on buddy list as online, by uid).
+
[phone] Jeff Connelly <[e-mail]> - 0.0
+
+* Initial version. Login only. Not publicly released.
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/LICENSE	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/Makefile.am	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,30 @@
+EXTRA_DIST = Makefile.mingw
+
+pkgdir = $(libdir)/purple-$(PURPLE_MAJOR_VERSION)
+
+SOURCES = myspace.c message.c
+
+AM_CFLAGS = $(st)
+
+libmyspace_la_LDFLAGS = -module -avoid-version
+
+if STATIC_MYSPACE
+
+st = -DPURPLE_STATIC_PRPL
+noinst_LIBRARIES     = libmyspace.a
+libmyspace_a_SOURCES = $(SOURCES)
+libmyspace_a_CFLAGS  = $(AM_CFLAGS)
+
+else
+
+st =
+pkg_LTLIBRARIES       = libmyspace.la
+libmyspace_la_SOURCES = $(SOURCES)
+libmyspace_la_LIBADD  = $(GLIB_LIBS)
+
+endif
+
+AM_CPPFLAGS = \
+	-I$(top_srcdir)/libpurple \
+	$(GLIB_CFLAGS) \
+	$(DEBUG_CFLAGS)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/Makefile.mingw	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,81 @@
+#
+# Makefile.mingw
+#
+# Description: Makefile for win32 (mingw) version of libmyspace
+#
+
+PIDGIN_TREE_TOP := ../../..
+include $(PIDGIN_TREE_TOP)/libpurple/win32/global.mak
+
+TARGET = libmyspace
+TYPE = PLUGIN
+
+# Static or Plugin...
+ifeq ($(TYPE),STATIC)
+  DEFINES += -DSTATIC
+  DLL_INSTALL_DIR =	$(PURPLE_INSTALL_DIR)
+else
+ifeq ($(TYPE),PLUGIN)
+  DLL_INSTALL_DIR =	$(PURPLE_INSTALL_PLUGINS_DIR)
+endif
+endif
+
+##
+## INCLUDE PATHS
+##
+INCLUDE_PATHS +=	-I. \
+			-I$(GTK_TOP)/include \
+			-I$(GTK_TOP)/include/glib-2.0 \
+			-I$(GTK_TOP)/lib/glib-2.0/include \
+			-I$(PURPLE_TOP) \
+			-I$(PURPLE_TOP)/win32 \
+			-I$(PIDGIN_TREE_TOP)
+
+LIB_PATHS =		-L$(GTK_TOP)/lib \
+			-L$(PURPLE_TOP)
+
+##
+##  SOURCES, OBJECTS
+##
+C_SRC =			myspace.c message.c
+
+OBJECTS = $(C_SRC:%.c=%.o)
+
+##
+## LIBRARIES
+##
+LIBS =	\
+			-lglib-2.0 \
+			-lws2_32 \
+			-lintl \
+			-lpurple
+
+include $(PIDGIN_COMMON_RULES)
+
+##
+## TARGET DEFINITIONS
+##
+.PHONY: all install clean
+
+all: $(TARGET).dll
+
+install: all $(DLL_INSTALL_DIR)
+	cp $(TARGET).dll $(DLL_INSTALL_DIR)
+
+$(OBJECTS): $(PURPLE_CONFIG_H)
+
+##
+## BUILD DLL
+##
+$(TARGET).dll: $(PURPLE_DLL).a $(OBJECTS)
+	$(CC) -shared $(OBJECTS) $(LIB_PATHS) $(LIBS) $(DLL_LD_FLAGS) -o $(TARGET).dll
+
+##
+## CLEAN RULES
+##
+
+clean:
+	rm -f $(OBJECTS)
+	rm -f $(TARGET).dll
+
+include $(PIDGIN_COMMON_TARGETS)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/README	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,34 @@
+MySpaceIM Protocol Plugin      by Jeff Connelly 20070807
+
+
+Greetings. This package contains a plugin for libpurple (as used in
+Pidgin, formerly Gaim) to connect to the new MySpaceIM instant messaging 
+network and send/receive messages. Functionality is only basic as of yet, 
+and this code should be considered alpha quality.
+
+This code is being developed under Google Summer of Code 2007.
+
+For features and TODO, see http://developer.pidgin.im/wiki/MySpaceIM
+
+Windows installation: Unzip the archive to C:\Program Files\Pidgin
+Unix/source installation: run "make install"
+
+Usage:
+
+Login using your _email address_ you use to login to myspace.com. You can't
+login using your numeric ID or alias.
+
+To test it out, send a message to yourself (by your username or numeric 
+uid (email not yet supported)) or tom (6221). In either case you should 
+get a reply. You should also be able to talk to other MySpaceIM users if 
+you desire. Replies will always be shown as coming from a user's username, 
+even if you IM by email or userid.
+
+Feedback welcome. You can IM my test account at "msimprpl" if you feel like it.
+
+Enjoy,
+-Jeff Connelly
+California Polytechnic State University at San Luis Obispo
[e-mail]
[e-mail]
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/message.c	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,1338 @@
+/** MySpaceIM protocol messages
+ *
+ * \author Jeff Connelly
+ *
+ * Copyright (C) 2007, Jeff Connelly <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "myspace.h"
+#include "message.h"
+
+static void msim_msg_free_element(gpointer data, gpointer user_data);
+static void msim_msg_debug_string_element(gpointer data, gpointer user_data);
+static gchar *msim_msg_pack_using(MsimMessage *msg, GFunc gf, const gchar *sep, const gchar *begin, const gchar *end);
+static GList *msim_msg_get_node(MsimMessage *msg, const gchar *name);
+static MsimMessage *msim_msg_new_v(gchar *first_key, va_list argp);
+
+/* Escape codes and associated replacement text, used for protocol message
+ * escaping and unescaping. */
+static struct MSIM_ESCAPE_REPLACEMENT {
+	gchar *code;
+	gchar text;
+} msim_escape_replacements[] = {
+	{ "/1", '/' },
+	{ "/2", '\\' },
+	/* { "/3", "|" }, */      /* Not used here -- only for within arrays */
+	{ NULL, 0 }
+};
+
+/**
+ * Escape a protocol message.
+ *
+ * @return The escaped message. Caller must g_free().
+ */
+gchar *
+msim_escape(const gchar *msg)
+{
+	GString *gs;
+	guint i, j;
+
+	gs = g_string_new("");
+
+
+	for (i = 0; i < strlen(msg); ++i) {
+		struct MSIM_ESCAPE_REPLACEMENT *replacement;
+		gchar *replace;
+
+		replace = NULL;
+
+		/* Check for characters that need to be escaped, and escape them. */
+		for (j = 0; (replacement = &msim_escape_replacements[j]) &&
+				replacement->code != NULL; ++j) {
+			if (msg[i] == replacement->text) {
+				replace = replacement->code;
+				break;
+			}
+		}
+
+		if (replace) {
+			g_string_append(gs, replace);
+		} else {
+			g_string_append_c(gs, msg[i]);
+		}
+	}
+
+#ifdef MSIM_DEBUG_ESCAPE
+	purple_debug_info("msim", "msim_escape: msg=%s, ret=%s\n", msg, gs->str);
+#endif
+
+	return gs->str;
+}
+
+/**
+ * Unescape a protocol message.
+ *
+ * @return The unescaped message, caller must g_free().
+ */
+gchar *
+msim_unescape(const gchar *msg)
+{
+	GString *gs;
+	guint i, j;
+
+	gs = g_string_new("");
+
+	for (i = 0; i < strlen(msg); ++i) {
+		struct MSIM_ESCAPE_REPLACEMENT *replacement;
+		gchar replace;
+
+		replace = msg[i];
+
+		for (j = 0; (replacement = &msim_escape_replacements[j]) &&
+				replacement->code != NULL; ++j) {
+			if (msg[i] == replacement->code[0] &&
+			    i + 1 < strlen(msg) &&
+			    msg[i + 1] == replacement->code[1]) {
+				replace = replacement->text;
+				++i;
+				break;
+			}
+		}
+
+		g_string_append_c(gs, replace);
+	}
+
+#ifdef MSIM_DEBUG_ESCAPE
+	purple_debug_info("msim", "msim_unescape: msg=%s, ret=%s\n", msg, gs->str);
+#endif
+
+	return gs->str;
+}
+
+/** Create a new MsimMessage. 
+ * 
+ * @param first_key The first key in the sequence, or NULL for an empty message.
+ * @param ... A sequence of gchar* key/type/value triplets, terminated with NULL. 
+ *
+ * See msim_msg_append() documentation for details on types.
+ */
+MsimMessage *
+msim_msg_new(gchar *first_key, ...)
+{
+	va_list argp;
+
+	if (first_key) {
+	va_start(argp, first_key);
+		return msim_msg_new_v(first_key, argp);
+	} else {
+		return NULL;
+	}
+}
+
+/** Create a new message from va_list and its first argument.
+ *
+ * @param first_key The first argument (a key), or NULL to take all arguments
+ *    from argp.
+ * @param argp A va_list of variadic arguments, already started with va_start(). Will be va_end()'d.
+ * @return New MsimMessage *, must be freed with msim_msg_free().
+ *
+ * For internal use - users probably want msim_msg_new() or msim_send().
+ */
+static MsimMessage *
+msim_msg_new_v(gchar *first_key, va_list argp)
+{
+	gchar *key, *value;
+	MsimMessageType type;
+	MsimMessage *msg;
+	gboolean first;
+
+	GString *gs;
+	GList *gl;
+	MsimMessage *dict;
+
+	/* Begin with an empty message. */
+	msg = NULL;
+
+	/* First parameter can be given explicitly. */
+	first = first_key != NULL;
+
+	/* Read key, type, value triplets until NULL. */
+	do {
+		if (first) {
+			key = first_key;
+			first = FALSE;
+		} else {
+			key = va_arg(argp, gchar *);
+			if (!key) {
+				break;
+			}
+		}
+
+		type = va_arg(argp, int);
+
+		/* Interpret variadic arguments. */
+		switch (type) {
+			case MSIM_TYPE_INTEGER: 
+			case MSIM_TYPE_BOOLEAN: 
+				msg = msim_msg_append(msg, key, type, GUINT_TO_POINTER(va_arg(argp, int)));
+				break;
+				
+			case MSIM_TYPE_STRING:
+				value = va_arg(argp, char *);
+
+				g_return_val_if_fail(value != NULL, FALSE);
+
+				msg = msim_msg_append(msg, key, type, value);
+				break;
+
+			case MSIM_TYPE_BINARY:
+				gs = va_arg(argp, GString *);
+
+				g_return_val_if_fail(gs != NULL, FALSE);
+
+				/* msim_msg_free() will free this GString the caller created. */
+				msg = msim_msg_append(msg, key, type, gs);
+				break;
+			
+			case MSIM_TYPE_LIST:
+				gl = va_arg(argp, GList *);
+
+				g_return_val_if_fail(gl != NULL, FALSE);
+
+				msg = msim_msg_append(msg, key, type, gl);
+				break;
+
+			case MSIM_TYPE_DICTIONARY:
+				dict = va_arg(argp, MsimMessage *);
+
+				g_return_val_if_fail(dict != NULL, FALSE);
+
+				msg = msim_msg_append(msg, key, type, dict);
+				break;
+
+			default:
+				purple_debug_info("msim", "msim_send: unknown type %d\n", type);
+				break;
+		}
+	} while(key);
+	va_end(argp);
+
+	return msg;
+}
+
+/** Perform a deep copy on a GList * of gchar * strings. Free with msim_msg_list_free(). */
+GList *
+msim_msg_list_copy(GList *old)
+{
+	GList *new_list;
+
+	new_list = NULL;
+
+	/* Deep copy (g_list_copy is shallow). Copy each string. */
+	for (; old != NULL; old = g_list_next(old)) {
+		new_list = g_list_append(new_list, g_strdup(old->data));
+	}
+
+	return new_list;
+}
+
+/** Free a GList * of gchar * strings. */
+void
+msim_msg_list_free(GList *l)
+{
+
+	for (; l != NULL; l = g_list_next(l)) {
+		g_free((gchar *)(l->data));
+	}
+	g_list_free(l);
+}
+
+/** Parse a |-separated string into a new GList. Free with msim_msg_list_free(). */
+GList *
+msim_msg_list_parse(const gchar *raw)
+{
+	gchar **array;
+	GList *list;
+	guint i;
+
+	array = g_strsplit(raw, "|", 0);
+	list = NULL;
+
+	/* TODO: escape/unescape /3 <-> | within list elements */
+	
+	for (i = 0; array[i] != NULL; ++i) {
+		list = g_list_append(list, g_strdup(array[i]));
+	}
+
+	g_strfreev(array);
+
+	return list;
+}
+
+/** Clone an individual element.
+ *
+ * @param data MsimMessageElement * to clone.
+ * @param user_data Pointer to MsimMessage * to add cloned element to.
+ */
+static void 
+msim_msg_clone_element(gpointer data, gpointer user_data)
+{
+	MsimMessageElement *elem;
+	MsimMessage **new;
+	gpointer new_data;
+				
+	GString *gs;
+	MsimMessage *dict;
+
+	elem = (MsimMessageElement *)data;
+	new = (MsimMessage **)user_data;
+
+	switch (elem->type) {
+		case MSIM_TYPE_BOOLEAN:
+		case MSIM_TYPE_INTEGER:
+			new_data = elem->data;
+			break;
+
+		case MSIM_TYPE_RAW:
+		case MSIM_TYPE_STRING:
+			new_data = g_strdup((gchar *)elem->data);
+			break;
+
+		case MSIM_TYPE_LIST:
+			new_data = (gpointer)msim_msg_list_copy((GList *)(elem->data));
+			break;
+
+		case MSIM_TYPE_BINARY:
+			gs = (GString *)elem->data;
+
+			new_data = g_string_new_len(gs->str, gs->len);
+			break;
+		case MSIM_TYPE_DICTIONARY:
+			dict = (MsimMessage *)elem->data;
+
+			new_data = msim_msg_clone(dict);
+			break;
+
+		default:
+			purple_debug_info("msim", "msim_msg_clone_element: unknown type %d\n", elem->type);
+			g_return_if_fail(NULL);
+	}
+
+	/* Append cloned data. Note that the 'name' field is a static string, so it
+	 * never needs to be copied nor freed. */
+	*new = msim_msg_append(*new, elem->name, elem->type, new_data);
+}
+
+/** Clone an existing MsimMessage. 
+ *
+ * @return Cloned message; caller should free with msim_msg_free().
+ */
+MsimMessage *
+msim_msg_clone(MsimMessage *old)
+{
+	MsimMessage *new;
+
+	if (old == NULL) {
+		return NULL;
+	}
+
+	new = msim_msg_new(FALSE);
+
+	g_list_foreach(old, msim_msg_clone_element, &new);
+
+	return new;
+}
+
+/** Free the data of a message element.
+ *
+ * @param elem The MsimMessageElement *
+ *
+ * Note this only frees the element data; you may also want to free the
+ * element itself with g_free() (see msim_msg_free_element()).
+ */
+void
+msim_msg_free_element_data(MsimMessageElement *elem)
+{
+	switch (elem->type) {
+		case MSIM_TYPE_BOOLEAN:
+		case MSIM_TYPE_INTEGER:
+			/* Integer value stored in gpointer - no need to free(). */
+			break;
+
+		case MSIM_TYPE_RAW:
+		case MSIM_TYPE_STRING:
+			/* Always free strings - caller should have g_strdup()'d if
+			 * string was static or temporary and not to be freed. */
+			g_free(elem->data);
+			break;
+
+		case MSIM_TYPE_BINARY:
+			/* Free the GString itself and the binary data. */
+			g_string_free((GString *)elem->data, TRUE);
+			break;
+
+		case MSIM_TYPE_DICTIONARY:
+			msim_msg_free((MsimMessage *)elem->data);
+			break;
+			
+		case MSIM_TYPE_LIST:
+			g_list_free((GList *)elem->data);
+			break;
+
+		default:
+			purple_debug_info("msim", "msim_msg_free_element_data: "
+					"not freeing unknown type %d\n", elem->type);
+			break;
+	}
+}
+
+/** Free an individual message element.
+ *
+ * @param data MsimMessageElement * to free.
+ * @param user_data Not used; required to match g_list_foreach() callback prototype.
+ *
+ * Frees both the element data and the element itself.
+ */
+static void 
+msim_msg_free_element(gpointer data, gpointer user_data)
+{
+	MsimMessageElement *elem;
+
+	elem = (MsimMessageElement *)data;
+
+	msim_msg_free_element_data(elem);
+
+	g_free(elem);
+}
+
+/** Free a complete message. */
+void 
+msim_msg_free(MsimMessage *msg)
+{
+	if (!msg) {
+		/* already free as can be */
+		return;
+	}
+
+#ifdef MSIM_MSG_DEBUG_FREE
+	msim_msg_dump("msim_msg_free: freeing %s", msg);
+#endif
+
+	g_list_foreach(msg, msim_msg_free_element, NULL);
+	g_list_free(msg);
+}
+
+/** Send an existing MsimMessage. */
+gboolean 
+msim_msg_send(MsimSession *session, MsimMessage *msg)
+{
+	gchar *raw;
+	gboolean success;
+	
+	raw = msim_msg_pack(msg);
+	g_return_val_if_fail(raw != NULL, FALSE);
+	success = msim_send_raw(session, raw);
+	g_free(raw);
+
+	msim_msg_dump("msim_msg_send()ing %s\n", msg);
+	
+	return success;
+}
+
+/**
+ *
+ * Send a message to the server, whose contents is specified using 
+ * variable arguments.
+ *
+ * @param session
+ * @param ... A sequence of gchar* key/type/value triplets, terminated with NULL. 
+ *
+ * This function exists for coding convenience: it allows a message to be created
+ * and sent in one line of code. Internally it calls msim_msg_send(). 
+ *
+ * IMPORTANT: See msim_msg_append() documentation for details on element types.
+ *
+ */
+gboolean 
+msim_send(MsimSession *session, ...)
+{
+	gboolean success;
+	MsimMessage *msg;
+	va_list argp;
+	
+	va_start(argp, session);
+	msg = msim_msg_new_v(NULL, argp);
+
+	/* Actually send the message. */
+	success = msim_msg_send(session, msg);
+
+	/* Cleanup. */
+	msim_msg_free(msg);
+
+	return success;
+}
+
+/** Create a new MsimMessageElement * - must be g_free()'d. 
+ *
+ * For internal use; users probably want msim_msg_append() or msim_msg_insert_before(). 
+ */
+static MsimMessageElement *
+msim_msg_element_new(const gchar *name, MsimMessageType type, gpointer data)
+{
+	MsimMessageElement *elem;
+
+	elem = g_new0(MsimMessageElement, 1);
+
+	elem->name = name;
+	elem->type = type;
+	elem->data = data;
+
+	return elem;
+}
+
+
+/** Append a new element to a message. 
+ *
+ * @param name Textual name of element (static string, neither copied nor freed).
+ * @param type An MSIM_TYPE_* code.
+ * @param data Pointer to data, see below.
+ *
+ * @return The new message - must be assigned to as with GList*. For example:
+ *
+ *     msg = msim_msg_append(msg, ...)
+ *
+ * The data parameter depends on the type given:
+ *
+ * * MSIM_TYPE_INTEGER: Use GUINT_TO_POINTER(x).
+ *
+ * * MSIM_TYPE_BINARY: Same as integer, non-zero is TRUE and zero is FALSE.
+ *
+ * * MSIM_TYPE_STRING: gchar *. The data WILL BE FREED - use g_strdup() if needed.
+ *
+ * * MSIM_TYPE_RAW: gchar *. The data WILL BE FREED - use g_strdup() if needed.
+ *
+ * * MSIM_TYPE_BINARY: g_string_new_len(data, length). The data AND GString will be freed.
+ *
+ * * MSIM_TYPE_DICTIONARY: An MsimMessage *. Freed when message is destroyed.
+ *
+ * * MSIM_TYPE_LIST: GList * of gchar *. Again, everything will be freed.
+ *
+ * */
+MsimMessage *
+msim_msg_append(MsimMessage *msg, const gchar *name, 
+		MsimMessageType type, gpointer data)
+{
+	return g_list_append(msg, msim_msg_element_new(name, type, data));
+}
+
+/** Insert a new element into a message, before the given element name.
+ *
+ * @param name_before Name of the element to insert the new element before. If 
+ *                    could not be found or NULL, new element will be inserted at end.
+ *
+ * See msim_msg_append() for usage of other parameters, and an important note about return value.
+ */
+MsimMessage *
+msim_msg_insert_before(MsimMessage *msg, const gchar *name_before, 
+		const gchar *name, MsimMessageType type, gpointer data)
+{
+	MsimMessageElement *new_elem;
+	GList *node_before;
+
+	new_elem = msim_msg_element_new(name, type, data);
+
+	node_before = msim_msg_get_node(msg, name_before);
+
+	return g_list_insert_before(msg, node_before, new_elem);
+}
+
+/** Pack a string using the given GFunc and seperator.
+ * Used by msim_msg_dump() and msim_msg_pack().
+ */
+gchar *
+msim_msg_pack_using(MsimMessage *msg, 
+		GFunc gf, 
+		const gchar *sep, 
+		const gchar *begin, const gchar *end)
+{
+	gchar **strings;
+	gchar **strings_tmp;
+	gchar *joined;
+	gchar *final;
+	int i;
+
+	g_return_val_if_fail(msg != NULL, NULL);
+
+	/* Add one for NULL terminator for g_strjoinv(). */
+	strings = (gchar **)g_new0(gchar *, g_list_length(msg) + 1);
+
+	strings_tmp = strings;
+	g_list_foreach(msg, gf, &strings_tmp);
+
+	joined = g_strjoinv(sep, strings);
+	final = g_strconcat(begin, joined, end, NULL);
+	g_free(joined);
+
+	/* Clean up. */
+	for (i = 0; i < g_list_length(msg); ++i) {
+		g_free(strings[i]);
+	}
+
+	g_free(strings);
+
+	return final;
+}
+/** Store a human-readable string describing the element.
+ *
+ * @param data Pointer to an MsimMessageElement.
+ * @param user_data 
+ */
+static void 
+msim_msg_debug_string_element(gpointer data, gpointer user_data)
+{
+	MsimMessageElement *elem;
+	gchar *string;
+	GString *gs;
+	gchar *binary;
+	gchar ***items;  /* wow, a pointer to a pointer to a pointer */
+	
+	gchar *s;
+	GList *gl;
+	guint i;
+
+	elem = (MsimMessageElement *)data;
+	items = user_data;
+
+	switch (elem->type) {
+		case MSIM_TYPE_INTEGER:
+			string = g_strdup_printf("%s(integer): %d", elem->name, 
+					GPOINTER_TO_UINT(elem->data));
+			break;
+
+		case MSIM_TYPE_RAW:
+			string = g_strdup_printf("%s(raw): %s", elem->name, 
+					elem->data ? (gchar *)elem->data : "(NULL)");
+			break;
+
+		case MSIM_TYPE_STRING:
+			string = g_strdup_printf("%s(string): %s", elem->name, 
+					elem->data ? (gchar *)elem->data : "(NULL)");
+			break;
+
+		case MSIM_TYPE_BINARY:
+			gs = (GString *)elem->data;
+			binary = purple_base64_encode((guchar*)gs->str, gs->len);
+			string = g_strdup_printf("%s(binary, %d bytes): %s", elem->name, (int)gs->len, binary);
+			g_free(binary);
+			break;
+
+		case MSIM_TYPE_BOOLEAN:
+			string = g_strdup_printf("%s(boolean): %s", elem->name,
+					elem->data ? "TRUE" : "FALSE");
+			break;
+
+		case MSIM_TYPE_DICTIONARY:
+			if (!elem->data) {
+				s = g_strdup("(NULL)");
+			} else {
+				s = msim_msg_dump_to_str((MsimMessage *)elem->data);
+			}
+
+			if (!s) {
+				s = g_strdup("(NULL, couldn't msim_msg_dump_to_str)");
+			}
+
+			string = g_strdup_printf("%s(dict): %s", elem->name, s);
+
+			g_free(s);
+			break;
+			
+		case MSIM_TYPE_LIST:
+			gs = g_string_new("");
+			g_string_append_printf(gs, "%s(list): \n", elem->name);
+
+			i = 0;
+			for (gl = (GList *)elem->data; gl != NULL; gl = g_list_next(gl)) {
+				g_string_append_printf(gs, " %d. %s\n", i, (gchar *)(gl->data));
+				++i;
+			}
+			
+			string = gs->str;
+			break;
+
+		default:
+			string = g_strdup_printf("%s(unknown type %d", 
+					elem->name ? elem->name : "(NULL)", elem->type);
+			break;
+	}
+
+	**items = string;
+	++(*items);
+}
+
+/** Print a human-readable string of the message to Purple's debug log.
+ *
+ * @param fmt_string A static string, in which '%s' will be replaced.
+ */
+void 
+msim_msg_dump(const gchar *fmt_string, MsimMessage *msg)
+{
+	gchar *debug_str;
+
+	g_return_if_fail(fmt_string != NULL);
+
+	debug_str = msim_msg_dump_to_str(msg);
+	
+	g_return_if_fail(debug_str != NULL);
+
+	purple_debug_info("msim", fmt_string, debug_str);
+
+	g_free(debug_str);
+}
+
+/** Return a human-readable string of the message.
+ *
+ * @return A new gchar *, must be g_free()'d.
+ */
+gchar *
+msim_msg_dump_to_str(MsimMessage *msg)
+{
+	gchar *debug_str;
+
+	if (!msg) {
+		debug_str = g_strdup("<MsimMessage: empty>");
+	} else {
+		debug_str = msim_msg_pack_using(msg, msim_msg_debug_string_element, 
+				"\n", "<MsimMessage: \n", "\n/MsimMessage>");
+	}
+
+	return debug_str;
+}
+
+/** Return a message element data as a new string for a raw protocol message, converting from other types (integer, etc.) if necessary.
+ *
+ * @return const gchar * The data as a string, or NULL. Caller must g_free().
+ *
+ * Returns a string suitable for inclusion in a raw protocol message, not necessarily
+ * optimal for human consumption. For example, strings are escaped. Use 
+ * msim_msg_get_string() if you want a string, which in some cases is same as this.
+ */
+gchar *
+msim_msg_pack_element_data(MsimMessageElement *elem)
+{
+	GString *gs;
+	GList *gl;
+
+	g_return_val_if_fail(elem != NULL, NULL);
+
+	switch (elem->type) {
+		case MSIM_TYPE_INTEGER:
+			return g_strdup_printf("%d", GPOINTER_TO_UINT(elem->data));
+
+		case MSIM_TYPE_RAW:
+			/* Not un-escaped - this is a raw element, already escaped if necessary. */
+			return (gchar *)g_strdup((gchar *)elem->data);
+
+		case MSIM_TYPE_STRING:
+			/* Strings get escaped. msim_escape() creates a new string. */
+			g_return_val_if_fail(elem->data != NULL, NULL);
+			return elem->data ? msim_escape((gchar *)elem->data) :
+				g_strdup("(NULL)");
+
+		case MSIM_TYPE_BINARY:
+			gs = (GString *)elem->data;
+			/* Do not escape! */
+			return purple_base64_encode((guchar *)gs->str, gs->len);
+
+		case MSIM_TYPE_BOOLEAN:
+			/* Not used by messages in the wire protocol * -- see msim_msg_pack_element.
+			 * Only used by dictionaries, see msim_msg_pack_element_dict. */
+			return elem->data ? g_strdup("On") : g_strdup("Off");
+
+		case MSIM_TYPE_DICTIONARY:
+			return msim_msg_pack_dict((MsimMessage *)elem->data);
+			
+		case MSIM_TYPE_LIST:
+			/* Pack using a|b|c|d|... */
+			gs = g_string_new("");
+
+			for (gl = (GList *)elem->data; gl != NULL; gl = g_list_next(gl)) {
+				g_string_append_printf(gs, "%s", (gchar*)(gl->data));
+				
+				/* All but last element is separated by a bar. */
+				if (g_list_next(gl)) 
+					g_string_append(gs, "|");
+			}
+			
+			return gs->str;
+
+		default:
+			purple_debug_info("msim", "field %s, unknown type %d\n", 
+					elem->name ? elem->name : "(NULL)", 
+					elem->type);
+			return NULL;
+	}
+}
+
+/** Pack an element into its protcol representation inside a dictionary.
+ *
+ * See msim_msg_pack_element().
+ */
+static void
+msim_msg_pack_element_dict(gpointer data, gpointer user_data)
+{
+	MsimMessageElement *elem;
+	gchar *string, *data_string, ***items;
+
+	elem = (MsimMessageElement *)data;
+	items = (gchar ***)user_data;
+
+	/* Exclude elements beginning with '_' from packed protocol messages. */
+	if (elem->name[0] == '_') {
+		return;
+	}
+
+	data_string = msim_msg_pack_element_data(elem);
+
+	g_return_if_fail(data_string != NULL);
+
+	switch (elem->type) {
+		/* These types are represented by key name/value pairs (converted above). */
+		case MSIM_TYPE_INTEGER:
+		case MSIM_TYPE_RAW:
+		case MSIM_TYPE_STRING:
+		case MSIM_TYPE_BINARY:
+		case MSIM_TYPE_DICTIONARY:
+		case MSIM_TYPE_LIST:
+		case MSIM_TYPE_BOOLEAN: /* Boolean is On or Off */
+			string = g_strconcat(elem->name, "=", data_string, NULL);
+			break;
+
+		default:
+			g_free(data_string);
+			g_return_if_fail(FALSE);
+			break;
+	}
+
+	g_free(data_string);
+
+	**items = string;
+	++(*items);
+}
+
+/** Pack an element into its protocol representation. 
+ *
+ * @param data Pointer to an MsimMessageElement.
+ * @param user_data Pointer to a gchar ** array of string items.
+ *
+ * Called by msim_msg_pack(). Will pack the MsimMessageElement into
+ * a part of the protocol string and append it to the array. Caller
+ * is responsible for creating array to correct dimensions, and
+ * freeing each string element of the array added by this function.
+ */
+static void 
+msim_msg_pack_element(gpointer data, gpointer user_data)
+{
+	MsimMessageElement *elem;
+	gchar *string, *data_string;
+	gchar ***items;
+
+	elem = (MsimMessageElement *)data;
+	items = (gchar ***)user_data;
+
+	/* Exclude elements beginning with '_' from packed protocol messages. */
+	if (elem->name[0] == '_') {
+		return;
+	}
+
+	data_string = msim_msg_pack_element_data(elem);
+
+	switch (elem->type) {
+		/* These types are represented by key name/value pairs (converted above). */
+		case MSIM_TYPE_INTEGER:
+		case MSIM_TYPE_RAW:
+		case MSIM_TYPE_STRING:
+		case MSIM_TYPE_BINARY:
+		case MSIM_TYPE_DICTIONARY:
+		case MSIM_TYPE_LIST:
+			string = g_strconcat(elem->name, "\\", data_string, NULL);
+			break;
+
+		/* Boolean is represented by absence or presence of name. */
+		case MSIM_TYPE_BOOLEAN:
+			if (GPOINTER_TO_UINT(elem->data)) {
+				/* True - leave in, with blank value. */
+				string = g_strdup_printf("%s\\", elem->name);
+			} else {
+				/* False - leave out. */
+				string = g_strdup("");
+			}
+			break;
+
+		default:
+			g_free(data_string);
+			g_return_if_fail(FALSE);
+			break;
+	}
+
+	g_free(data_string);
+
+	**items = string;
+	++(*items);
+}
+
+
+/** Return a packed string of a message suitable for sending over the wire.
+ *
+ * @return A string. Caller must g_free().
+ */
+gchar *
+msim_msg_pack(MsimMessage *msg)
+{
+	g_return_val_if_fail(msg != NULL, NULL);
+
+	return msim_msg_pack_using(msg, msim_msg_pack_element, "\\", "\\", "\\final\\");
+}
+
+/** Return a packed string of a dictionary, suitable for embedding in MSIM_TYPE_DICTIONARY.
+ *
+ * @return A string; caller must g_free().
+ */
+gchar *
+msim_msg_pack_dict(MsimMessage *msg)
+{
+	g_return_val_if_fail(msg != NULL, NULL);
+
+	return msim_msg_pack_using(msg, msim_msg_pack_element_dict, "\034", "", "");
+}
+
+/** 
+ * Parse a raw protocol message string into a MsimMessage *.
+ *
+ * @param raw The raw message string to parse, will be g_free()'d.
+ *
+ * @return MsimMessage *. Caller should msim_msg_free() when done.
+ */
+MsimMessage *
+msim_parse(gchar *raw)
+{
+	MsimMessage *msg;
+	gchar *token;
+	gchar **tokens;
+	gchar *key;
+	gchar *value;
+	int i;
+
+	g_return_val_if_fail(raw != NULL, NULL);
+
+	purple_debug_info("msim", "msim_parse: got <%s>\n", raw);
+
+	key = NULL;
+
+	/* All messages begin with a \. */
+	if (raw[0] != '\\' || raw[1] == 0) {
+		purple_debug_info("msim", "msim_parse: incomplete/bad string, "
+				"missing initial backslash: <%s>\n", raw);
+		/* XXX: Should we try to recover, and read to first backslash? */
+
+		g_free(raw);
+		return NULL;
+	}
+
+	msg = msim_msg_new(FALSE);
+
+	for (tokens = g_strsplit(raw + 1, "\\", 0), i = 0; 
+			(token = tokens[i]);
+			i++) {
+#ifdef MSIM_DEBUG_PARSE
+		purple_debug_info("msim", "tok=<%s>, i%2=%d\n", token, i % 2);
+#endif
+		if (i % 2) {
+			/* Odd-numbered ordinal is a value. */
+
+			value = token;
+		
+			/* Incoming protocol messages get tagged as MSIM_TYPE_RAW, which
+			 * represents an untyped piece of data. msim_msg_get_* will
+			 * convert to appropriate types for caller, and handle unescaping if needed. */
+			msg = msim_msg_append(msg, g_strdup(key), MSIM_TYPE_RAW, g_strdup(value));
+#ifdef MSIM_DEBUG_PARSE
+			purple_debug_info("msim", "insert string: |%s|=|%s|\n", key, value);
+#endif
+		} else {
+			/* Even numbered indexes are key names. */
+			key = token;
+		}
+	}
+	g_strfreev(tokens);
+
+	/* Can free now since all data was copied to hash key/values */
+	g_free(raw);
+
+	return msg;
+}
+
+/** Search for and return the node in msg, matching name, or NULL. 
+ *
+ * @param msg Message to search within.
+ * @param name Field name to search for.
+ *
+ * @return The GList * node for the MsimMessageElement with the given name, or NULL if not found or name is NULL.
+ *
+ * For internal use - users probably want to use msim_msg_get() to
+ * access the MsimMessageElement *, instead of the GList * container.
+ *
+ */
+static GList *
+msim_msg_get_node(MsimMessage *msg, const gchar *name)
+{
+	GList *node;
+
+	if (!name || !msg) {
+		return NULL;
+	}
+
+	/* Linear search for the given name. O(n) but n is small. */
+	for (node = msg; node != NULL; node = g_list_next(node)) {
+		MsimMessageElement *elem;
+
+		elem = (MsimMessageElement *)node->data;
+
+		g_return_val_if_fail(elem != NULL, NULL);
+		g_return_val_if_fail(elem->name != NULL, NULL);
+
+		if (strcmp(elem->name, name) == 0) {
+			return node;
+		}
+	}
+	return NULL;
+}
+
+/** Return the first MsimMessageElement * with given name in the MsimMessage *. 
+ *
+ * @param name Name to search for.
+ *
+ * @return MsimMessageElement * matching name, or NULL.
+ *
+ * Note: useful fields of MsimMessageElement are 'data' and 'type', which
+ * you can access directly. But it is often more convenient to use
+ * another msim_msg_get_* that converts the data to what type you want.
+ */
+MsimMessageElement *
+msim_msg_get(MsimMessage *msg, const gchar *name)
+{
+	GList *node;
+
+	node = msim_msg_get_node(msg, name);
+	if (node) {
+		return (MsimMessageElement *)node->data;
+	} else {
+		return NULL;
+	}
+}
+
+/** Return the data of an element of a given name, as a string.
+ *
+ * @param name Name of element.
+ *
+ * @return gchar * The data as a string, or NULL if not found. 
+ *     Caller must g_free().
+ *
+ * Note that msim_msg_pack_element_data() is similar, but returns a string
+ * for inclusion into a raw protocol string (escaped and everything).
+ * This function unescapes the string for you, if needed.
+ */
+gchar *
+msim_msg_get_string(MsimMessage *msg, const gchar *name)
+{
+	MsimMessageElement *elem;
+
+	elem = msim_msg_get(msg, name);
+	if (!elem) {
+		return NULL;
+	}
+
+	return msim_msg_get_string_from_element(elem);
+}
+
+gchar *
+msim_msg_get_string_from_element(MsimMessageElement *elem)
+{
+	g_return_val_if_fail(elem != NULL, NULL);
+	switch (elem->type) {
+		case MSIM_TYPE_INTEGER:
+			return g_strdup_printf("%d", GPOINTER_TO_UINT(elem->data));
+
+		case MSIM_TYPE_RAW:
+			/* Raw element from incoming message - if its a string, it'll
+			 * be escaped. */
+			return msim_unescape((gchar *)elem->data);
+
+		case MSIM_TYPE_STRING:
+			/* Already unescaped. */
+			return g_strdup((gchar *)elem->data);
+
+		default:
+			purple_debug_info("msim", "msim_msg_get_string_element: type %d unknown, name %s\n",
+					elem->type, elem->name ? elem->name : "(NULL)");
+			return NULL;
+	}
+}
+
+/** Return an element as a new list. Caller frees with msim_msg_list_free(). */
+GList *
+msim_msg_get_list(MsimMessage *msg, const gchar *name)
+{
+	MsimMessageElement *elem;
+
+	elem = msim_msg_get(msg, name);
+	if (!elem) {
+		return NULL;
+	}
+
+	return msim_msg_get_list_from_element(elem);
+}
+
+GList *
+msim_msg_get_list_from_element(MsimMessageElement *elem)
+{
+	g_return_val_if_fail(elem != NULL, NULL);
+	switch (elem->type) {
+		case MSIM_TYPE_LIST:
+			return msim_msg_list_copy((GList *)elem->data);
+
+		case MSIM_TYPE_RAW:
+			return msim_msg_list_parse((gchar *)elem->data);
+
+		default:
+			purple_debug_info("msim_msg_get_list", "type %d unknown, name %s\n",
+					elem->type, elem->name ? elem->name : "(NULL)");
+			return NULL;
+	}
+}
+
+/**
+ * Parse a \x1c-separated "dictionary" of key=value pairs into a hash table.
+ *
+ * @param raw The text of the dictionary to parse. Often the
+ *                 value for the 'body' field.
+ *
+ * @return A new MsimMessage *. Must msim_msg_free() when done.
+ */
+MsimMessage *
+msim_msg_dictionary_parse(gchar *raw)
+{
+	MsimMessage *dict;
+	gchar *item;
+	gchar **items;
+	gchar **elements;
+	guint i;
+
+	g_return_val_if_fail(raw != NULL, NULL);
+
+	dict = msim_msg_new(NULL);
+ 
+	for (items = g_strsplit(raw, "\x1c", 0), i = 0; 
+		(item = items[i]);
+		i++) {
+		gchar *key, *value;
+
+		elements = g_strsplit(item, "=", 2);
+
+		key = elements[0];
+		if (!key) {
+			purple_debug_info("msim", "msim_msg_parse_dictionary(%s): null key\n", 
+					raw);
+			g_strfreev(elements);
+			break;
+		}
+
+		value = elements[1];
+		if (!value) {
+			purple_debug_info("msim", "msim_msg_parse_dictionary(%s): null value\n", 
+					raw);
+			g_strfreev(elements);
+			break;
+		}
+
+#ifdef MSIM_DEBUG_PARSE
+		purple_debug_info("msim_msg_parse_dictionary","-- %s: %s\n", key ? key : "(NULL)", 
+				value ? value : "(NULL)");
+#endif
+		/* TODO: free key; right now it is treated as static */
+		dict = msim_msg_append(dict, g_strdup(key), MSIM_TYPE_RAW, g_strdup(value));
+
+		g_strfreev(elements);
+	}
+
+	g_strfreev(items);
+
+	return dict;
+}
+
+/** Return an element as a new dictionary. Caller frees with msim_msg_free(). */
+MsimMessage *
+msim_msg_get_dictionary(MsimMessage *msg, const gchar *name)
+{
+	MsimMessageElement *elem;
+
+	elem = msim_msg_get(msg, name);
+	if (!elem) {
+		return NULL;
+	}
+
+	return msim_msg_get_dictionary_from_element(elem);
+}
+
+MsimMessage *
+msim_msg_get_dictionary_from_element(MsimMessageElement *elem)
+{
+	g_return_val_if_fail(elem != NULL, NULL);
+	switch (elem->type) {
+		case MSIM_TYPE_DICTIONARY:
+			return msim_msg_clone((MsimMessage *)elem->data);
+		
+		case MSIM_TYPE_RAW:
+			return msim_msg_dictionary_parse((gchar *)elem->data);
+
+		default:
+			purple_debug_info("msim_msg_get_dictionary", "type %d unknown, name %s\n",
+					elem->type, elem->name ? elem->name : "(NULL)");
+			return NULL;
+	}
+}
+
+/** Return the data of an element of a given name, as an unsigned integer.
+ *
+ * @param name Name of element.
+ *
+ * @return guint Numeric representation of data, or 0 if could not be converted / not found.
+ *
+ * Useful to obtain an element's data if you know it should be an integer,
+ * even if it is not stored as an MSIM_TYPE_INTEGER. MSIM_TYPE_STRING will
+ * be converted handled correctly, for example.
+ */
+guint 
+msim_msg_get_integer(MsimMessage *msg, const gchar *name)
+{
+	MsimMessageElement *elem;
+
+	elem = msim_msg_get(msg, name);
+
+	if (!elem) {
+		return 0;
+	}
+
+	return msim_msg_get_integer_from_element(elem);
+}
+
+
+guint
+msim_msg_get_integer_from_element(MsimMessageElement *elem)
+{
+	g_return_val_if_fail(elem != NULL, 0);
+	switch (elem->type) {
+		case MSIM_TYPE_INTEGER:
+			return GPOINTER_TO_UINT(elem->data);
+
+		case MSIM_TYPE_RAW:
+		case MSIM_TYPE_STRING:
+			/* TODO: find out if we need larger integers */
+			return (guint)atoi((gchar *)elem->data);
+
+		default:
+			return 0;
+	}
+}
+
+/** Return the data of an element of a given name, as a binary GString.
+ *
+ * @param binary_data A pointer to a new pointer, which will be filled in with the binary data. CALLER MUST g_free().
+ *
+ * @param binary_length A pointer to an integer, which will be set to the binary data length.
+ *
+ * @return TRUE if successful, FALSE if not.
+ */
+gboolean 
+msim_msg_get_binary(MsimMessage *msg, const gchar *name, 
+		gchar **binary_data, gsize *binary_length)
+{
+	MsimMessageElement *elem;
+				
+	elem = msim_msg_get(msg, name);
+	if (!elem) {
+		return FALSE;
+	}
+
+	return msim_msg_get_binary_from_element(elem, binary_data, binary_length);
+}
+
+gboolean
+msim_msg_get_binary_from_element(MsimMessageElement *elem, gchar **binary_data, gsize *binary_length)
+{
+	GString *gs;
+
+	g_return_val_if_fail(elem != NULL, FALSE);
+
+	switch (elem->type) {
+		case MSIM_TYPE_RAW:
+			 /* Incoming messages are tagged with MSIM_TYPE_RAW, and
+			 * converted appropriately. They can still be "strings", just they won't
+			 * be tagged as MSIM_TYPE_STRING (as MSIM_TYPE_STRING is intended to be used
+			 * by msimprpl code for things like instant messages - stuff that should be
+			 * escaped if needed). DWIM.
+			 */
+	
+			/* Previously, incoming messages were stored as MSIM_TYPE_STRING.
+			 * This was fine for integers and strings, since they can easily be
+			 * converted in msim_get_*, as desirable. However, it does not work
+			 * well for binary strings. Consider:
+			 *
+			 * If incoming base64'd elements were tagged as MSIM_TYPE_STRING.
+			 * msim_msg_get_binary() sees MSIM_TYPE_STRING, base64 decodes, returns.
+			 * everything is fine.
+			 * But then, msim_send() is called on the incoming message, which has
+			 * a base64'd MSIM_TYPE_STRING that really is encoded binary. The values
+			 * will be escaped since strings are escaped, and / becomes /2; no good.
+			 *
+			 */
+			*binary_data = (gchar *)purple_base64_decode((const gchar *)elem->data, binary_length);
+			return TRUE;
+
+		case MSIM_TYPE_BINARY:
+			gs = (GString *)elem->data;
+
+			/* Duplicate data, so caller can g_free() it. */
+			*binary_data = g_new0(char, gs->len);
+			memcpy(*binary_data, gs->str, gs->len);
+
+			*binary_length = gs->len;
+
+			return TRUE;
+
+
+			/* Rejected because if it isn't already a GString, have to g_new0 it and
+			 * then caller has to ALSO free the GString! 
+			 *
+			 * return (GString *)elem->data; */
+
+		default:
+			purple_debug_info("msim", "msim_msg_get_binary: unhandled type %d for key %s\n",
+					elem->type, elem->name ? elem->name : "(NULL)");
+			return FALSE;
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/message.h	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,117 @@
+/** MySpaceIM protocol messages
+ *
+ * \author Jeff Connelly
+ *
+ * Copyright (C) 2007, Jeff Connelly <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MYSPACE_MESSAGE_H
+#define _MYSPACE_MESSAGE_H
+
+#include <glib.h>
+
+/* Types */
+#define MsimMessage GList               /* #define instead of typedef to avoid casting */
+typedef struct _MsimMessageElement
+{
+	const gchar *name;              /**< Textual name of element. */
+	guint type;                     /**< MSIM_TYPE_* code. */
+	gpointer data;                  /**< Pointer to data, or GUINT_TO_POINTER for int/bool. */
+} MsimMessageElement;
+
+typedef gchar MsimMessageType;
+
+#define msim_msg_get_next_element_node(msg)    ((MsimMessage *)(msg->next))
+
+/* Protocol field types */
+#define MSIM_TYPE_RAW            '-'
+#define MSIM_TYPE_INTEGER        'i'
+#define MSIM_TYPE_STRING         's'
+#define MSIM_TYPE_BINARY         'b'
+#define MSIM_TYPE_BOOLEAN        'f'
+#define MSIM_TYPE_DICTIONARY     'd'
+#define MSIM_TYPE_LIST           'l'
+
+gchar *msim_escape(const gchar *msg);
+gchar *msim_unescape(const gchar *msg);
+
+MsimMessage *msim_msg_new(gchar *first_key, ...);
+/* No sentinel attribute, because can leave off varargs if not_empty is FALSE. */
+
+MsimMessage *msim_msg_clone(MsimMessage *old);
+void msim_msg_free_element_data(MsimMessageElement *elem);
+void msim_msg_free(MsimMessage *msg);
+MsimMessage *msim_msg_append(MsimMessage *msg, const gchar *name, MsimMessageType type, gpointer data);
+MsimMessage *msim_msg_insert_before(MsimMessage *msg, const gchar *name_before, const gchar *name, MsimMessageType type, gpointer data);
+gchar *msim_msg_dump_to_str(MsimMessage *msg);
+gchar *msim_msg_pack_element_data(MsimMessageElement *elem);
+void msim_msg_dump(const char *fmt_string, MsimMessage *msg);
+gchar *msim_msg_pack(MsimMessage *msg);
+gchar *msim_msg_pack_dict(MsimMessage *msg);
+
+GList *msim_msg_list_copy(GList *old);
+void msim_msg_list_free(GList *l);
+GList *msim_msg_list_parse(const gchar *raw);
+
+/* Defined in myspace.h */
+struct _MsimSession;
+
+/* Based on http://permalink.gmane.org/gmane.comp.parsers.sparse/695 
+ * Define macros for useful gcc attributes. */
+#ifdef __GNUC__
+#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
+#define FORMAT_ATTR(pos) __attribute__ ((__format__ (__printf__, pos, pos+1)))
+#define NORETURN_ATTR __attribute__ ((__noreturn__))
+/* __sentinel__ attribute was introduced in gcc 3.5 */
+#if (GCC_VERSION >= 3005)
+	#define SENTINEL_ATTR __attribute__ ((__sentinel__(0)))
+#else
+	#define SENTINEL_ATTR
+#endif /* gcc >= 3.5 */
+#else
+	#define FORMAT_ATTR(pos)
+	#define NORETURN_ATTR
+	#define SENTINEL_ATTR
+#endif 
+
+/* Cause gcc to emit "a missing sentinel in function call" if forgot
+ * to write NULL as last, terminating parameter. */
+gboolean msim_send(struct _MsimSession *session, ...) SENTINEL_ATTR;
+
+gboolean msim_msg_send(struct _MsimSession *session, MsimMessage *msg);
+
+MsimMessage *msim_parse(gchar *raw);
+MsimMessage *msim_msg_dictionary_parse(gchar *raw);
+
+MsimMessageElement *msim_msg_get(MsimMessage *msg, const gchar *name);
+
+/* Retrieve data by name */
+gchar *msim_msg_get_string(MsimMessage *msg, const gchar *name);
+GList *msim_msg_get_list(MsimMessage *msg, const gchar *name);
+MsimMessage *msim_msg_get_dictionary(MsimMessage *msg, const gchar *name);
+guint msim_msg_get_integer(MsimMessage *msg, const gchar *name);
+gboolean msim_msg_get_binary(MsimMessage *msg, const gchar *name, gchar **binary_data, gsize *binary_length);
+
+/* Retrieve data by element (MsimMessageElement *), returned from msim_msg_get() */
+gchar *msim_msg_get_string_from_element(MsimMessageElement *elem);
+GList *msim_msg_get_list_from_element(MsimMessageElement *elem);
+MsimMessage *msim_msg_get_dictionary_from_element(MsimMessageElement *elem);
+guint msim_msg_get_integer_from_element(MsimMessageElement *elem);
+gboolean msim_msg_get_binary_from_element(MsimMessageElement *elem, 
+		gchar **binary_data, gsize *binary_length);
+
+#endif /* _MYSPACE_MESSAGE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/myspace.c	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,4406 @@
+/* MySpaceIM Protocol Plugin
+ *
+ * \author Jeff Connelly
+ *
+ * Copyright (C) 2007, Jeff Connelly <[e-mail]>
+ *
+ * Based on Purple's "C Plugin HOWTO" hello world example.
+ *
+ * Code also drawn from mockprpl:
+ *  http://snarfed.org/space/purple+mock+protocol+plugin
+ *  Copyright (C) 2004-2007, Ryan Barrett <[e-mail]>
+ *
+ * and some constructs also based on existing Purple plugins, which are:
+ *   Copyright (C) 2003, Robbert Haarman <[e-mail]>
+ *   Copyright (C) 2003, Ethan Blanton <[e-mail]>
+ *   Copyright (C) 2000-2003, Rob Flynn <[e-mail]>
+ *   Copyright (C) 1998-1999, Mark Spencer <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define PURPLE_PLUGIN
+
+#include "message.h"
+#include "persist.h"
+#include "myspace.h"
+
+/* Globals */
+
+/* The names in in emoticon_names (for <i n=whatever>) map to corresponding 
+ * entries in emoticon_symbols (for the ASCII representation of the emoticon).
+ *
+ * Multiple emoticon symbols in Pidgin can map to one name. List the
+ * canonical form, as inserted by the "Smile!" dialog, first. For example,
+ * :) comes before :-), because although both are recognized as 'happy',
+ * the first is inserted by the smiley button (first symbol in theme).
+ *
+ * Note that symbols are case-sensitive in Pidgin -- :-X is not :-x. */
+static struct MSIM_EMOTICON
+{
+	gchar *name;
+	gchar *symbol;
+} msim_emoticons[] = {
+	/* Unfortunately, this list duplicates much of the file
+	 * pidgin/pidgin/pixmaps/emotes/default/22/default.theme.in, because
+	 * that file is part of Pidgin, but we're part of libpurple.
+	 */
+	{ "bigsmile", ":D" },
+	{ "bigsmile", ":-D" },
+	{ "devil", "}:)" },
+	{ "frazzled", ":Z" },
+	{ "geek", "B)" },
+	{ "googles", "%)" },
+	{ "growl", ":E" },
+	{ "laugh", ":))" },		/* Must be before ':)' */
+	{ "happy", ":)" },
+	{ "happy", ":-)" },
+	{ "happi", ":)" },
+	{ "heart", ":X" },
+	{ "mohawk", "-:" },
+	{ "mad", "X(" },
+	{ "messed", "X)" },
+	{ "nerd", "Q)" },
+	{ "oops", ":G" },
+	{ "pirate", "P)" },
+	{ "scared", ":O" },
+	{ "sidefrown", ":{" },
+	{ "sinister", ":B" },
+	{ "smirk", ":," },
+	{ "straight", ":|" },
+	{ "tongue", ":P" },
+	{ "tongue", ":p" },
+	{ "tongy", ":P" },
+	{ "upset", "B|" },
+	{ "wink", ";-)" },
+	{ "wink", ";)" },
+	{ "winc", ";)" },
+	{ "worried", ":[" },
+	{ "kiss", ":x" },
+	{ NULL, NULL }
+};
+
+/* Internal functions */
+static gboolean msim_send_zap(MsimSession *session, const gchar *username, guint code);
+static void msim_send_zap_from_menu(PurpleBlistNode *node, gpointer zap_num_ptr);
+
+#ifdef MSIM_DEBUG_MSG
+static void print_hash_item(gpointer key, gpointer value, gpointer user_data);
+#endif
+
+static int msim_send_really_raw(PurpleConnection *gc, const char *buf,
+		int total_bytes);
+static gboolean msim_login_challenge(MsimSession *session, MsimMessage *msg);
+static const gchar *msim_compute_login_response(
+		const gchar nonce[2 * NONCE_SIZE], const gchar *email, 
+		const gchar *password, guint *response_len);
+static gboolean msim_send_bm(MsimSession *session, const gchar *who, 
+		const gchar *text, int type);
+
+static guint msim_point_to_purple_size(MsimSession *session, guint point);
+static guint msim_purple_size_to_point(MsimSession *session, guint size);
+static guint msim_height_to_point(MsimSession *session, guint height);
+static guint msim_point_to_height(MsimSession *session, guint point);
+
+static void msim_unrecognized(MsimSession *session, MsimMessage *msg, gchar *note);
+
+static void msim_markup_tag_to_html(MsimSession *, xmlnode *root, 
+		gchar **begin, gchar **end);
+static void html_tag_to_msim_markup(MsimSession *, xmlnode *root, 
+		gchar **begin, gchar **end);
+static gchar *msim_convert_xml(MsimSession *, const gchar *raw, 
+		MSIM_XMLNODE_CONVERT f);
+static gchar *msim_convert_smileys_to_markup(gchar *before);
+
+/* High-level msim markup <=> html conversion functions. */
+static gchar *msim_markup_to_html(MsimSession *, const gchar *raw);
+static gchar *html_to_msim_markup(MsimSession *, const gchar *raw);
+
+static MsimUser *msim_get_user_from_buddy(PurpleBuddy *buddy);
+static MsimUser *msim_find_user(MsimSession *session, const gchar *username);
+
+static gboolean msim_incoming_bm_record_cv(MsimSession *session, 
+		MsimMessage *msg);
+static gboolean msim_incoming_bm(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_status(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_im(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_zap(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_action(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_media(MsimSession *session, MsimMessage *msg);
+static gboolean msim_incoming_unofficial_client(MsimSession *session, 
+		MsimMessage *msg);
+
+#ifdef MSIM_SEND_CLIENT_VERSION
+static gboolean msim_send_unofficial_client(MsimSession *session, 
+		gchar *username);
+#endif
+
+static void msim_get_info_cb(MsimSession *session, MsimMessage *userinfo, gpointer data);
+static gchar *msim_format_now_playing(gchar *band, gchar *song);
+
+static void msim_set_status_code(MsimSession *session, guint code, 
+		gchar *statstring);
+
+static void msim_append_user_info(MsimSession *session, PurpleNotifyUserInfo *user_info, MsimUser *user, gboolean full);
+
+static void msim_downloaded_buddy_icon(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text,
+		gsize len, const gchar *error_message);
+
+static void msim_store_user_info_each(const gchar *key_str, gchar *value_str, MsimUser *user);
+static gboolean msim_store_user_info(MsimSession *session, MsimMessage *msg, MsimUser *user);
+static gboolean msim_process_server_info(MsimSession *session, 
+		MsimMessage *msg);
+static gboolean msim_web_challenge(MsimSession *session, MsimMessage *msg); 
+static gboolean msim_process_reply(MsimSession *session, MsimMessage *msg);
+
+static gboolean msim_preprocess_incoming(MsimSession *session, MsimMessage *msg);
+
+#ifdef MSIM_USE_KEEPALIVE
+static gboolean msim_check_alive(gpointer data);
+#endif
+
+static gboolean msim_we_are_logged_on(MsimSession *session, MsimMessage *msg);
+
+static gboolean msim_process(MsimSession *session, MsimMessage *msg);
+
+static MsimMessage *msim_do_postprocessing(MsimMessage *msg, 
+		const gchar *uid_field_name, const gchar *uid_before, guint uid);
+static void msim_postprocess_outgoing_cb(MsimSession *session, 
+		MsimMessage *userinfo, gpointer data);
+static gboolean msim_postprocess_outgoing(MsimSession *session, 
+		MsimMessage *msg, const gchar *username, const gchar *uid_field_name, 
+		const gchar *uid_before); 
+
+static gboolean msim_error(MsimSession *session, MsimMessage *msg);
+
+static void msim_check_inbox_cb(MsimSession *session, MsimMessage *userinfo, 
+		gpointer data);
+static gboolean msim_check_inbox(gpointer data);
+
+static void msim_input_cb(gpointer gc_uncasted, gint source, 
+		PurpleInputCondition cond);
+
+static guint msim_new_reply_callback(MsimSession *session, 
+		MSIM_USER_LOOKUP_CB cb, gpointer data);
+
+static void msim_connect_cb(gpointer data, gint source, 
+		const gchar *error_message);
+
+static gboolean msim_is_userid(const gchar *user);
+static gboolean msim_is_email(const gchar *user);
+
+static void msim_lookup_user(MsimSession *session, const gchar *user, 
+		MSIM_USER_LOOKUP_CB cb, gpointer data);
+
+static void msim_import_friends(PurplePluginAction *action);
+
+double msim_round(double round);
+
+/* round is part of C99, but sometimes is unavailable before then.
+ * Based on http://forums.belution.com/en/cpp/000/050/13.shtml
+ */
+double msim_round(double value)
+{
+	if (value < 0) {
+		return -(floor(-value + 0.5));
+	} else {
+		return   floor( value + 0.5);
+	}
+}
+
+/** 
+ * Load the plugin.
+ */
+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;
+}
+
+/**
+ * Get possible user status types. Based on mockprpl.
+ *
+ * @return GList of status types.
+ */
+GList *
+msim_status_types(PurpleAccount *acct)
+{
+	GList *types;
+	PurpleStatusType *status;
+
+	purple_debug_info("myspace", "returning status types\n");
+
+	types = NULL;
+
+    /* Statuses are almost all the same. Define a macro to reduce code repetition. */
+#define _MSIM_ADD_NEW_STATUS(prim) status =                         \
+	purple_status_type_new_with_attrs(                          \
+	prim,   /* PurpleStatusPrimitive */                         \
+	NULL,   /* id - use default */                              \
+	NULL,   /* name - use default */                            \
+	TRUE,   /* savable */                                       \
+	TRUE,   /* user_settable */                                 \
+	FALSE,  /* not independent */                               \
+	                                                            \
+	/* Attributes - each status can have a message. */          \
+	"message",                                                  \
+	_("Message"),                                               \
+	purple_value_new(PURPLE_TYPE_STRING),                       \
+	NULL);                                                      \
+	                                                            \
+	                                                            \
+	types = g_list_append(types, status)
+
+
+	_MSIM_ADD_NEW_STATUS(PURPLE_STATUS_AVAILABLE);
+	_MSIM_ADD_NEW_STATUS(PURPLE_STATUS_AWAY);
+	_MSIM_ADD_NEW_STATUS(PURPLE_STATUS_OFFLINE);
+	_MSIM_ADD_NEW_STATUS(PURPLE_STATUS_INVISIBLE);
+
+
+	return types;
+}
+
+/** Get zap types. */
+GList *
+msim_attention_types(PurpleAccount *acct)
+{
+	static GList *types = NULL;
+	MsimAttentionType* attn;
+
+	if (!types) {
+#define _MSIM_ADD_NEW_ATTENTION(icn, des, incoming, outgoing)              \
+		attn = g_new0(MsimAttentionType, 1);                     \
+		attn->icon = icn;                                          \
+		attn->description = des;                                   \
+		attn->incoming_description = incoming;                     \
+		attn->outgoing_description = outgoing;                     \
+		types = g_list_append(types, attn);
+
+		/* TODO: icons for each zap */
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("zap"), _("zapped"), _("Zapping"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("whack"), _("whacked"), _("Whacking"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("torch"), _("torched"), _("Torching"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("smooch"), _("smooched"), _("Smooching"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("hug"), _("hugged"), _("Hugging"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("bslap"), _("bslapped"), _("Bslapping"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("goose"), _("goosed"), _("Goosing"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("hi-five"), _("hi-fived"), _("Hi-fiving"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("punk"), _("punk'd"), _("Punking"));
+		_MSIM_ADD_NEW_ATTENTION(NULL, _("raspberry"), _("raspberried"), _("Raspberry'ing"));
+	}
+
+	return types;
+}
+
+/** Send a zap */
+gboolean
+msim_send_attention(PurpleConnection *gc, gchar *username, guint code)
+{
+	GList *types;
+	MsimSession *session;
+	MsimAttentionType *attn;
+	PurpleBuddy *buddy;
+
+	session = (MsimSession *)gc->proto_data;
+
+	/* Look for this attention type, by the code index given. */
+	types = msim_attention_types(gc->account);
+	attn = (MsimAttentionType *)g_list_nth_data(types, code);
+
+	if (!attn) {
+		purple_debug_info("msim_send_attention", "got invalid zap code %d\n", code);
+		return FALSE;
+	}
+
+	buddy = purple_find_buddy(session->account, username);
+	if (!buddy) {
+		return FALSE;
+	}
+
+	/* TODO: make use of the MsimAttentionType we found, instead of
+	 * doing it all over in msim_send_zap_from_menu. */
+	msim_send_zap_from_menu(&buddy->node, GUINT_TO_POINTER(code));
+
+	return TRUE;
+}
+
+/** Send a zap to a user. */
+static gboolean
+msim_send_zap(MsimSession *session, const gchar *username, guint code)
+{
+	gchar *zap_string;
+#ifndef MSIM_USE_ATTENTION_API
+	gchar *zap_description;
+#endif
+	GList *types;
+	MsimAttentionType *attn;
+	gboolean rc;
+
+	g_return_val_if_fail(session != NULL, FALSE);
+	g_return_val_if_fail(username != NULL, FALSE);
+
+	types = msim_attention_types(session->account);
+
+	attn = g_list_nth_data(types, code);
+	if (!attn) {
+		return FALSE;
+	}
+
+
+#ifdef MSIM_USE_ATTENTION_API
+	serv_got_attention(session->gc, username, attn, FALSE);
+#else
+	zap_description = g_strdup_printf("*** Attention: %s %s ***", attn->outgoing_description,
+			username);
+
+	serv_got_im(session->gc, username, zap_description,
+			PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_SYSTEM, time(NULL));
+
+	g_free(zap_description);
+#endif
+
+	/* Construct and send the actual zap command. */
+	zap_string = g_strdup_printf("!!!ZAP_SEND!!!=RTE_BTN_ZAPS_%d", code);
+
+	if (!msim_send_bm(session, username, zap_string, MSIM_BM_ACTION)) {
+		purple_debug_info("msim_send_zap_from_menu", "msim_send_bm failed: zapping %s with %s",
+				username, zap_string);
+		rc = FALSE;
+	} else {
+		rc = TRUE;
+	}
+	
+	g_free(zap_string);
+
+	return rc;
+
+}
+
+/** Zap someone. Callback from msim_blist_node_menu zap menu. */
+static void
+msim_send_zap_from_menu(PurpleBlistNode *node, gpointer zap_num_ptr)
+{
+	PurpleBuddy *buddy;
+	PurpleAccount *account;
+	PurpleConnection *gc;
+	MsimSession *session;
+	guint zap;
+
+	if (!PURPLE_BLIST_NODE_IS_BUDDY(node)) {
+		/* Only know about buddies for now. */
+		return;
+	}
+
+	g_return_if_fail(PURPLE_BLIST_NODE_IS_BUDDY(node));
+
+	buddy = (PurpleBuddy *)node;
+
+	/* Find the session */
+	account = buddy->account;
+	gc = purple_account_get_connection(account);
+	session = (MsimSession *)gc->proto_data;
+
+	zap = GPOINTER_TO_INT(zap_num_ptr);
+
+	g_return_if_fail(msim_send_zap(session, buddy->name, zap));
+}
+
+
+/** Return menu, if any, for a buddy list node. */
+GList *
+msim_blist_node_menu(PurpleBlistNode *node)
+{
+	GList *menu, *zap_menu;
+	GList *types;
+	PurpleMenuAction *act;
+	/* Warning: hardcoded to match that in msim_attention_types. */
+	const gchar *zap_names[10];
+	guint i;
+
+	if (!PURPLE_BLIST_NODE_IS_BUDDY(node)) {
+		/* Only know about buddies for now. */
+		return NULL;
+	}
+
+	/* Names from official client. */
+	types = msim_attention_types(NULL);
+	i = 0;
+	do
+	{
+		MsimAttentionType *attn;
+
+		attn = (MsimAttentionType *)types->data;
+		zap_names[i] = attn->description;
+		++i;
+	} while ((types = g_list_next(types)));
+
+	menu = zap_menu = NULL;
+
+	/* TODO: get rid of once is accessible directly in GUI */
+	for (i = 0; i < sizeof(zap_names) / sizeof(zap_names[0]); ++i) {
+		act = purple_menu_action_new(zap_names[i], PURPLE_CALLBACK(msim_send_zap_from_menu),
+				GUINT_TO_POINTER(i), NULL);
+		zap_menu = g_list_append(zap_menu, act);
+	}
+
+	act = purple_menu_action_new(_("Zap"), NULL, NULL, zap_menu);
+	menu = g_list_append(menu, act);
+
+	return menu;
+}
+
+/**
+ * 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.
+ */
+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";
+}
+
+/**
+ * Replace 'old' with 'new' in 'str'.
+ *
+ * @param str The original string.
+ * @param old The substring of 'str' to replace.
+ * @param new The replacement for 'old' within 'str'.
+ *
+ * @return A _new_ string, based on 'str', with 'old' replaced
+ *         by 'new'. Must be g_free()'d by caller.
+ *
+ * This string replace method is based on
+ * http://mail.gnome.org/archives/gtk-app-devel-list/2000-July/msg00201.html
+ *
+ */
+gchar *
+str_replace(const gchar *str, const gchar *old, const gchar *new)
+{
+	gchar **items;
+	gchar *ret;
+
+	items = g_strsplit(str, old, -1);
+	ret = g_strjoinv(new, items);
+	g_free(items);
+	return ret;
+}
+
+#ifdef MSIM_DEBUG_MSG
+static void 
+print_hash_item(gpointer key, gpointer value, gpointer user_data)
+{
+	purple_debug_info("msim", "%s=%s\n",
+			key ? (gchar *)key : "(NULL)", 
+			value ? (gchar *)value : "(NULL)");
+}
+#endif
+
+/** 
+ * Send raw data (given as a NUL-terminated string) to the server.
+ *
+ * @param session 
+ * @param msg The raw data to send, in a NUL-terminated string.
+ *
+ * @return TRUE if succeeded, FALSE if not.
+ *
+ */
+gboolean 
+msim_send_raw(MsimSession *session, const gchar *msg)
+{
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+	
+	purple_debug_info("msim", "msim_send_raw: writing <%s>\n", msg);
+
+	return msim_send_really_raw(session->gc, msg, strlen(msg)) ==
+		strlen(msg);
+}
+
+/** 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;
+
+	g_return_val_if_fail(gc != NULL, -1);
+	g_return_val_if_fail(buf != NULL, -1);
+	g_return_val_if_fail(total_bytes >= 0, -1);
+
+	session = (MsimSession *)gc->proto_data;
+
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), -1);
+	
+	/* Loop until all data is sent, or a failure occurs. */
+	total_bytes_sent = 0;
+	do {
+		int bytes_sent;
+
+		bytes_sent = send(session->fd, buf + total_bytes_sent, 
+				total_bytes - total_bytes_sent, 0);
+
+		if (bytes_sent < 0) {
+			purple_debug_info("msim", "msim_send_raw(%s): send() failed: %s\n",
+					buf, g_strerror(errno));
+			return total_bytes_sent;
+		}
+		total_bytes_sent += bytes_sent;
+
+	} while(total_bytes_sent < total_bytes);
+
+	return total_bytes_sent;
+}
+
+
+/** 
+ * Start logging in to the MSIM servers.
+ * 
+ * @param acct Account information to use to login.
+ */
+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;
+
+#ifdef MSIM_MAX_PASSWORD_LENGTH
+	/* Passwords are limited in length. */
+	if (strlen(acct->password) > MSIM_MAX_PASSWORD_LENGTH) {
+		gchar *str;
+
+		str = g_strdup_printf(
+				_("Sorry, passwords over %d characters in length (yours is "
+				"%d) are not supported by MySpace."), 
+				MSIM_MAX_PASSWORD_LENGTH,
+				(int)strlen(acct->password));
+
+		/* Notify an error message also, because this is important! */
+		purple_notify_error(acct, g_strdup(_("MySpaceIM Error")), str, NULL);
+
+		purple_connection_error(gc, str);
+		
+		g_free(str);
+	}
+#endif
+
+	/* 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(gc, _("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;
+	const gchar *response;
+	guint response_len;
+	gchar *nc;
+	gsize nc_len;
+
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+
+	g_return_val_if_fail(msim_msg_get_binary(msg, "nc", &nc, &nc_len), FALSE);
+
+	account = session->account;
+
+	g_return_val_if_fail(account != NULL, FALSE);
+
+	purple_connection_update_progress(session->gc, _("Reading challenge"), 1, 4);
+
+	purple_debug_info("msim", "nc is %d bytes, decoded\n", nc_len);
+
+	if (nc_len != MSIM_AUTH_CHALLENGE_LENGTH) {
+		purple_debug_info("msim", "bad nc length: %x != 0x%x\n", nc_len, MSIM_AUTH_CHALLENGE_LENGTH);
+		purple_connection_error(session->gc, _("Unexpected challenge length from server"));
+		return FALSE;
+	}
+
+	purple_connection_update_progress(session->gc, _("Logging in"), 2, 4);
+
+	response_len = 0;
+	response = msim_compute_login_response(nc, account->username, account->password, &response_len);
+
+	g_free(nc);
+
+	return msim_send(session, 
+			"login2", MSIM_TYPE_INTEGER, MSIM_AUTH_ALGORITHM,
+			/* This is actually user's email address. */
+			"username", MSIM_TYPE_STRING, g_strdup(account->username),
+			/* GString and gchar * response will be freed in msim_msg_free() in msim_send(). */
+			"response", MSIM_TYPE_BINARY, g_string_new_len(response, response_len),
+			"clientver", MSIM_TYPE_INTEGER, MSIM_CLIENT_VERSION,
+			"langid", MSIM_TYPE_INTEGER, MSIM_LANGUAGE_ID_ENGLISH,
+			"imlang", MSIM_TYPE_STRING, g_strdup(MSIM_LANGUAGE_NAME_ENGLISH),
+			"reconn", MSIM_TYPE_INTEGER, 0,
+			"status", MSIM_TYPE_INTEGER, 100,
+			"id", MSIM_TYPE_INTEGER, 1,
+			NULL);
+}
+
+/**
+ * Compute the base64'd login challenge response based on username, password, nonce, and IPs.
+ *
+ * @param nonce The base64 encoded nonce ('nc') field from the server.
+ * @param email User's email address (used as login name).
+ * @param password User's cleartext password.
+ * @param response_len Will be written with response length.
+ *
+ * @return Binary login challenge response, ready to send to the server. 
+ * Must be g_free()'d when finished. NULL if error.
+ */
+static const gchar *
+msim_compute_login_response(const gchar nonce[2 * NONCE_SIZE], 
+		const gchar *email, const gchar *password, guint *response_len)
+{
+	PurpleCipherContext *key_context;
+	PurpleCipher *sha1;
+	PurpleCipherContext *rc4;
+
+	guchar hash_pw[HASH_SIZE];
+	guchar key[HASH_SIZE];
+	gchar *password_utf16le, *password_utf8_lc;
+	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);
+	g_return_val_if_fail(email != NULL, NULL);
+	g_return_val_if_fail(password != NULL, NULL);
+	g_return_val_if_fail(response_len != NULL, NULL);
+
+	/* Convert password to lowercase (required for passwords containing
+	 * uppercase characters). MySpace passwords are lowercase,
+	 * see ticket #2066. */
+	password_utf8_lc = g_utf8_strdown(password, -1);
+
+	/* Convert ASCII password to UTF16 little endian */
+	purple_debug_info("msim", "converting password to UTF-16LE\n");
+	conv_error = NULL;
+	password_utf16le = g_convert(password_utf8_lc, -1, "UTF-16LE", "UTF-8", 
+			&conv_bytes_read, &conv_bytes_written, &conv_error);
+	g_free(password_utf8_lc);
+
+	g_return_val_if_fail(conv_bytes_read == strlen(password), NULL);
+
+	if (conv_error != NULL) {
+		purple_debug_error("msim", 
+				"g_convert password UTF8->UTF16LE failed: %s",
+				conv_error->message);
+		g_error_free(conv_error);
+		return NULL;
+	}
+
+	/* Compute password hash */ 
+	purple_cipher_digest_region("sha1", (guchar *)password_utf16le, 
+			conv_bytes_written, sizeof(hash_pw), hash_pw, NULL);
+	g_free(password_utf16le);
+
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
+	purple_debug_info("msim", "pwhash = ");
+	for (i = 0; i < sizeof(hash_pw); i++)
+		purple_debug_info("msim", "%.2x ", hash_pw[i]);
+	purple_debug_info("msim", "\n");
+#endif
+
+	/* key = sha1(sha1(pw) + nonce2) */
+	sha1 = purple_ciphers_find_cipher("sha1");
+	key_context = purple_cipher_context_new(sha1, NULL);
+	purple_cipher_context_append(key_context, hash_pw, HASH_SIZE);
+	purple_cipher_context_append(key_context, (guchar *)(nonce + NONCE_SIZE), NONCE_SIZE);
+	purple_cipher_context_digest(key_context, sizeof(key), key, NULL);
+
+#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
+	purple_debug_info("msim", "key = ");
+	for (i = 0; i < sizeof(key); i++) {
+		purple_debug_info("msim", "%.2x ", key[i]);
+	}
+	purple_debug_info("msim", "\n");
+#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_assert(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 (const 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).
+		 */
+		/* TODO: maybe if message is delayed, don't echo to conv window,
+		 * but do echo it to conv window manually once it is actually
+		 * sent? Would be complicated. */
+		rc = 1;
+	} else {
+		rc = -1;
+	}
+
+	g_free(message_msim);
+
+	/*
+	 * In MySpace, you login with your email address, but don't talk to other
+	 * users using their email address. So there is currently an asymmetry in the 
+	 * IM windows when using this plugin:
+	 *
+	 * [e-mail]: hello
+	 * some_other_user: what's going on?
+	 * [e-mail]: just coding a prpl
+	 *
+	 * TODO: Make the sent IM's appear as from the user's username, instead of
+	 * their email address. Purple uses the login (in MSIM, the email)--change this.
+	 */
+
+	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.
+ *
+ */
+static 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;
+}
+
+/* Indexes of this array + 1 map HTML font size to scale of normal font size. *
+ * Based on _point_sizes from libpurple/gtkimhtml.c 
+ *                                 1    2  3    4     5      6       7 */
+static gdouble _font_scale[] = { .85, .95, 1, 1.2, 1.44, 1.728, 2.0736 };
+
+#define MAX_FONT_SIZE                   7       /* Purple maximum font size */
+#define POINTS_PER_INCH                 72      /* How many pt's in an inch */
+
+/** Convert typographical font point size to HTML font size. 
+ * Based on libpurple/gtkimhtml.c */
+static guint
+msim_point_to_purple_size(MsimSession *session, guint point)
+{
+	guint size, this_point, base;
+	gdouble scale;
+	
+	base = purple_account_get_int(session->account, "base_font_size", MSIM_BASE_FONT_POINT_SIZE);
+   
+	for (size = 0; 
+			size < sizeof(_font_scale) / sizeof(_font_scale[0]);
+			++size) {
+		scale = _font_scale[CLAMP(size, 1, MAX_FONT_SIZE) - 1];
+		this_point = (guint)msim_round(scale * base);
+
+		if (this_point >= point) {
+			purple_debug_info("msim", "msim_point_to_purple_size: %d pt -> size=%d\n",
+					point, size);
+			return size;
+		}
+	}
+
+	/* No HTML font size was this big; return largest possible. */
+	return this_point;
+}
+
+/** Convert HTML font size to point size. */
+static guint
+msim_purple_size_to_point(MsimSession *session, guint size)
+{
+	gdouble scale;
+	guint point;
+	guint base;
+
+	scale = _font_scale[CLAMP(size, 1, MAX_FONT_SIZE) - 1];
+
+	base = purple_account_get_int(session->account, "base_font_size", MSIM_BASE_FONT_POINT_SIZE);
+
+	point = (guint)msim_round(scale * base);
+
+	purple_debug_info("msim", "msim_purple_size_to_point: size=%d -> %d pt\n",
+					size, point);
+
+	return point;
+}
+
+/** Convert a msim markup font pixel height to the more usual point size, for incoming messages. */
+static guint 
+msim_height_to_point(MsimSession *session, guint height)
+{
+	guint dpi;
+
+	dpi = purple_account_get_int(session->account, "port", MSIM_DEFAULT_DPI);
+
+	return (guint)msim_round((POINTS_PER_INCH * 1. / dpi) * height);
+
+	/* See also: libpurple/protocols/bonjour/jabber.c
+	 * _font_size_ichat_to_purple */
+}
+
+/** Convert point size to msim pixel height font size specification, for outgoing messages. */
+static guint
+msim_point_to_height(MsimSession *session, guint point)
+{
+	guint dpi;
+
+	dpi = purple_account_get_int(session->account, "port", MSIM_DEFAULT_DPI);
+
+	return (guint)msim_round((dpi * 1. / POINTS_PER_INCH) * point);
+}
+
+/** Convert the msim markup <f> (font) tag into HTML. */
+static void 
+msim_markup_f_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	const gchar *face, *height_str, *decor_str;
+	GString *gs_end, *gs_begin;
+	guint decor, height;
+
+	face = xmlnode_get_attrib(root, "f");
+	height_str = xmlnode_get_attrib(root, "h");
+	decor_str = xmlnode_get_attrib(root, "s");
+
+	if (height_str) {
+		height = atol(height_str);
+	} else {
+		height = 12;
+	}
+
+	if (decor_str) {
+		decor = atol(decor_str);
+	} else {
+		decor = 0;
+	}
+
+	gs_begin = g_string_new("");
+	/* TODO: get font size working */
+	if (height && !face) {
+		g_string_printf(gs_begin, "<font size='%d'>", 
+				msim_point_to_purple_size(session, msim_height_to_point(session, height)));
+	} else if (height && face) {
+		g_string_printf(gs_begin, "<font face='%s' size='%d'>", face,  
+				msim_point_to_purple_size(session, msim_height_to_point(session, height)));
+	} else {
+		g_string_printf(gs_begin, "<font>");
+	}
+
+	/* No support for font-size CSS? */
+	/* g_string_printf(gs_begin, "<span style='font-family: %s; font-size: %dpt'>", face, 
+			msim_height_to_point(height)); */
+
+	gs_end = g_string_new("</font>");
+
+	if (decor & MSIM_TEXT_BOLD) {
+		g_string_append(gs_begin, "<b>");
+		g_string_prepend(gs_end, "</b>");
+	}
+
+	if (decor & MSIM_TEXT_ITALIC) {
+		g_string_append(gs_begin, "<i>");
+		g_string_append(gs_end, "</i>");
+	}
+
+	if (decor & MSIM_TEXT_UNDERLINE) {
+		g_string_append(gs_begin, "<u>");
+		g_string_append(gs_end, "</u>");
+	}
+
+
+	*begin = gs_begin->str;
+	*end = gs_end->str;
+}
+
+/** Convert a msim markup color to a color suitable for libpurple.
+  *
+  * @param msim Either a color name, or an rgb(x,y,z) code.
+  *
+  * @return A new string, either a color name or #rrggbb code. Must g_free(). 
+  */
+static char *
+msim_color_to_purple(const char *msim)
+{
+	guint red, green, blue;
+
+	if (!msim) {
+		return g_strdup("black");
+	}
+
+	if (sscanf(msim, "rgb(%d,%d,%d)", &red, &green, &blue) != 3) {
+		/* Color name. */
+		return g_strdup(msim);
+	}
+	/* TODO: rgba (alpha). */
+
+	return g_strdup_printf("#%.2x%.2x%.2x", red, green, blue);
+}
+
+/** Convert the msim markup <a> (anchor) tag into HTML. */
+static void 
+msim_markup_a_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	const gchar *href;
+
+	href = xmlnode_get_attrib(root, "h");
+	if (!href) {
+		href = "";
+	}
+
+	*begin = g_strdup_printf("<a href=\"%s\">%s", href, href);
+	*end = g_strdup("</a>");
+}
+
+/** Convert the msim markup <p> (paragraph) tag into HTML. */
+static void 
+msim_markup_p_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	/* Just pass through unchanged. 
+	 *
+	 * Note: attributes currently aren't passed, if there are any. */
+	*begin = g_strdup("<p>");
+	*end = g_strdup("</p>");
+}
+
+/** Convert the msim markup <c> tag (text color) into HTML. TODO: Test */
+static void 
+msim_markup_c_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	const gchar *color;
+	gchar *purple_color;
+
+	color = xmlnode_get_attrib(root, "v");
+	if (!color) {
+		purple_debug_info("msim", "msim_markup_c_to_html: <c> tag w/o v attr");
+		*begin = g_strdup("");
+		*end = g_strdup("");
+		/* TODO: log as unrecognized */
+		return;
+	}
+
+	purple_color = msim_color_to_purple(color);
+
+	*begin = g_strdup_printf("<font color='%s'>", purple_color); 
+
+	g_free(purple_color);
+
+	/* *begin = g_strdup_printf("<span style='color: %s'>", color); */
+	*end = g_strdup("</font>");
+}
+
+/** Convert the msim markup <b> tag (background color) into HTML. TODO: Test */
+static void 
+msim_markup_b_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	const gchar *color;
+	gchar *purple_color;
+
+	color = xmlnode_get_attrib(root, "v");
+	if (!color) {
+		*begin = g_strdup("");
+		*end = g_strdup("");
+		purple_debug_info("msim", "msim_markup_b_to_html: <b> w/o v attr");
+		/* TODO: log as unrecognized. */
+		return;
+	}
+
+	purple_color = msim_color_to_purple(color);
+
+	/* TODO: find out how to set background color. */
+	*begin = g_strdup_printf("<span style='background-color: %s'>", 
+			purple_color);
+	g_free(purple_color);
+
+	*end = g_strdup("</p>");
+}
+
+/** Convert the msim markup <i> tag (emoticon image) into HTML. */
+static void 
+msim_markup_i_to_html(MsimSession *session, xmlnode *root, gchar **begin, gchar **end)
+{
+	const gchar *name;
+	guint i;
+	struct MSIM_EMOTICON *emote;
+
+	name = xmlnode_get_attrib(root, "n");
+	if (!name) {
+		purple_debug_info("msim", "msim_markup_i_to_html: <i> w/o n");
+		*begin = g_strdup("");
+		*end = g_strdup("");
+		/* TODO: log as unrecognized */
+		return;
+	}
+
+	/* Find and use canonical form of smiley symbol. */
+	for (i = 0; (emote = &msim_emoticons[i]) && emote->name != NULL; ++i) {
+		if (!strcmp(name, emote->name)) {
+			*begin = g_strdup(emote->symbol);
+			*end = g_strdup("");
+			return;
+		}
+	}
+
+	/* Couldn't find it, sorry. Try to degrade gracefully. */
+	*begin = g_strdup_printf("**%s**", name);
+	*end = g_strdup("");
+}
+
+/** Convert an individual msim markup tag to HTML. */
+static void 
+msim_markup_tag_to_html(MsimSession *session, xmlnode *root, gchar **begin, 
+		gchar **end)
+{
+	if (!strcmp(root->name, "f")) {
+		msim_markup_f_to_html(session, root, begin, end);
+	} else if (!strcmp(root->name, "a")) {
+		msim_markup_a_to_html(session, root, begin, end);
+	} else if (!strcmp(root->name, "p")) {
+		msim_markup_p_to_html(session, root, begin, end);
+	} else if (!strcmp(root->name, "c")) {
+		msim_markup_c_to_html(session, root, begin, end);
+	} else if (!strcmp(root->name, "b")) {
+		msim_markup_b_to_html(session, root, begin, end);
+	} else if (!strcmp(root->name, "i")) {
+		msim_markup_i_to_html(session, root, begin, end);
+	} else {
+		purple_debug_info("msim", "msim_markup_tag_to_html: "
+				"unknown tag name=%s, ignoring", 
+				(root && root->name) ? root->name : "(NULL)");
+		*begin = g_strdup("");
+		*end = g_strdup("");
+	}
+}
+
+/** Convert an individual HTML tag to msim markup. */
+static void 
+html_tag_to_msim_markup(MsimSession *session, xmlnode *root, gchar **begin, 
+		gchar **end)
+{
+	/* TODO: Coalesce nested tags into one <f> tag!
+	 * Currently, the 's' value will be overwritten when b/i/u is nested
+	 * within another one, and only the inner-most formatting will be 
+	 * applied to the text. */
+	if (!purple_utf8_strcasecmp(root->name, "root")) {
+		*begin = g_strdup("");
+		*end = g_strdup("");
+	} else if (!purple_utf8_strcasecmp(root->name, "b")) {
+		*begin = g_strdup_printf("<f s='%d'>", MSIM_TEXT_BOLD);
+		*end = g_strdup("</f>");
+	} else if (!purple_utf8_strcasecmp(root->name, "i")) {
+		*begin = g_strdup_printf("<f s='%d'>", MSIM_TEXT_ITALIC);
+		*end = g_strdup("</f>");
+	} else if (!purple_utf8_strcasecmp(root->name, "u")) {
+		*begin = g_strdup_printf("<f s='%d'>", MSIM_TEXT_UNDERLINE);
+		*end = g_strdup("</f>");
+	} else if (!purple_utf8_strcasecmp(root->name, "a")) {
+		const gchar *href, *link_text;
+
+		href = xmlnode_get_attrib(root, "href");
+
+		if (!href) {
+			href = xmlnode_get_attrib(root, "HREF");
+		}
+
+		link_text = xmlnode_get_data(root);
+
+		if (href) {
+			if (!strcmp(link_text, href)) {
+				/* Purple gives us: <a href="URL">URL</a>
+				 * Translate to <a h='URL' />
+				 * Displayed as text of URL with link to URL
+				 */
+				*begin = g_strdup_printf("<a h='%s' />", href);
+			} else {
+				/* But if we get: <a href="URL">text</a>
+				 * Translate to: text: <a h='URL' />
+				 *
+				 * Because official client only supports self-closed <a>
+				 * tags; you can't change the link text.
+				 */
+				*begin = g_strdup_printf("%s: <a h='%s' />", link_text, href);
+			}
+		} else {
+			*begin = g_strdup("<a />");
+		}
+
+		/* Sorry, kid. MySpace doesn't support you within <a> tags. */
+		xmlnode_free(root->child);
+		root->child = NULL;
+
+		*end = g_strdup("");
+	} else if (!purple_utf8_strcasecmp(root->name, "font")) {
+		const gchar *size;
+		const gchar *face;
+
+		size = xmlnode_get_attrib(root, "size");
+		face = xmlnode_get_attrib(root, "face");
+
+		if (face && size) {
+			*begin = g_strdup_printf("<f f='%s' h='%d'>", face, 
+					msim_point_to_height(session,
+						msim_purple_size_to_point(session, atoi(size))));
+		} else if (face) {
+			*begin = g_strdup_printf("<f f='%s'>", face);
+		} else if (size) {
+			*begin = g_strdup_printf("<f h='%d'>", 
+					 msim_point_to_height(session,
+						 msim_purple_size_to_point(session, atoi(size))));
+		} else {
+			*begin = g_strdup("<f>");
+		}
+
+		*end = g_strdup("</f>");
+
+		/* TODO: color (bg uses <body>), emoticons */
+	} else {
+		*begin = g_strdup_printf("[%s]", root->name);
+		*end = g_strdup_printf("[/%s]", root->name);
+	}
+}
+
+/** Convert an xmlnode of msim markup or HTML to an HTML string or msim markup.
+ *
+ * @param f Function to convert tags.
+ *
+ * @return An HTML string. Caller frees.
+ */
+static gchar *
+msim_convert_xmlnode(MsimSession *session, xmlnode *root, MSIM_XMLNODE_CONVERT f)
+{
+	xmlnode *node;
+	gchar *begin, *inner, *end;
+	GString *final;
+
+	if (!root || !root->name) {
+		return g_strdup("");
+	}
+
+	purple_debug_info("msim", "msim_convert_xmlnode: got root=%s\n",
+			root->name);
+
+	begin = inner = end = NULL;
+
+	final = g_string_new("");
+
+	f(session, root, &begin, &end);
+	
+	g_string_append(final, begin);
+
+	/* Loop over all child nodes. */
+	for (node = root->child; node != NULL; node = node->next) {
+		switch (node->type) {
+		case XMLNODE_TYPE_ATTRIB:
+			/* Attributes handled above. */
+			break;
+
+		case XMLNODE_TYPE_TAG:
+			/* A tag or tag with attributes. Recursively descend. */
+			inner = msim_convert_xmlnode(session, node, f);
+			g_return_val_if_fail(inner != NULL, NULL);
+
+			purple_debug_info("msim", " ** node name=%s\n", 
+					(node && node->name) ? node->name : "(NULL)");
+			break;
+	
+		case XMLNODE_TYPE_DATA:
+			/* Literal text. */
+			inner = g_new0(char, node->data_sz + 1);
+			strncpy(inner, node->data, node->data_sz);
+			inner[node->data_sz] = 0;
+
+			purple_debug_info("msim", " ** node data=%s\n", 
+					inner ? inner : "(NULL)");
+			break;
+			
+		default:
+			purple_debug_info("msim",
+					"msim_convert_xmlnode: strange node\n");
+			inner = g_strdup("");
+		}
+
+		if (inner) {
+			g_string_append(final, inner);
+		}
+	}
+
+	/* TODO: Note that msim counts each piece of text enclosed by <f> as
+	 * a paragraph and will display each on its own line. You actually have
+	 * to _nest_ <f> tags to intersperse different text in one paragraph!
+	 * Comment out this line below to see. */
+	g_string_append(final, end);
+
+	purple_debug_info("msim", "msim_markup_xmlnode_to_gtkhtml: RETURNING %s\n",
+			(final && final->str) ? final->str : "(NULL)");
+
+	return final->str;
+}
+
+/** Convert XML to something based on MSIM_XMLNODE_CONVERT. */
+static gchar *
+msim_convert_xml(MsimSession *session, const gchar *raw, MSIM_XMLNODE_CONVERT f)
+{
+	xmlnode *root;
+	gchar *str;
+	gchar *enclosed_raw;
+
+	g_return_val_if_fail(raw != NULL, NULL);
+
+	/* Enclose text in one root tag, to try to make it valid XML for parsing. */
+	enclosed_raw = g_strconcat("<root>", raw, "</root>", NULL);
+
+	root = xmlnode_from_str(enclosed_raw, -1);
+
+	if (!root) {
+		purple_debug_info("msim", "msim_markup_to_html: couldn't parse "
+				"%s as XML, returning raw: %s\n", enclosed_raw, raw);
+		/* TODO: msim_unrecognized */
+		g_free(enclosed_raw);
+		return g_strdup(raw);
+	}
+
+	g_free(enclosed_raw);
+
+	str = msim_convert_xmlnode(session, root, f);
+	g_return_val_if_fail(str != NULL, NULL);
+	purple_debug_info("msim", "msim_markup_to_html: returning %s\n", str);
+
+	xmlnode_free(root);
+
+	return str;
+}
+
+/** Convert plaintext smileys to <i> markup tags.
+ *
+ * @param before Original text with ASCII smileys. Will be freed.
+ * @return A new string with <i> tags, if applicable. Must be g_free()'d.
+ */
+static gchar *
+msim_convert_smileys_to_markup(gchar *before)
+{
+	gchar *old, *new, *replacement;
+	guint i;
+	struct MSIM_EMOTICON *emote;
+
+	old = before;
+	new = NULL;
+
+	for (i = 0; (emote = &msim_emoticons[i]) && emote->name != NULL; ++i) {
+		gchar *name, *symbol;
+
+		name = emote->name;
+		symbol = emote->symbol;
+
+		replacement = g_strdup_printf("<i n=\"%s\"/>", name);
+
+		purple_debug_info("msim", "msim_convert_smileys_to_markup: %s->%s\n",
+				symbol ? symbol : "(NULL)", 
+				replacement ? replacement : "(NULL)");
+		new = str_replace(old, symbol, replacement);
+		
+		g_free(replacement);
+		g_free(old);
+
+		old = new;
+	}
+
+	return new;
+}
+	
+
+/** High-level function to convert MySpaceIM markup to Purple (HTML) markup. 
+ *
+ * @return Purple markup string, must be g_free()'d. */
+static gchar *
+msim_markup_to_html(MsimSession *session, const gchar *raw)
+{
+	return msim_convert_xml(session, raw, 
+			(MSIM_XMLNODE_CONVERT)(msim_markup_tag_to_html));
+}
+
+/** High-level function to convert Purple (HTML) to MySpaceIM markup.
+ *
+ * @return HTML markup string, must be g_free()'d. */
+static gchar *
+html_to_msim_markup(MsimSession *session, const gchar *raw)
+{
+	gchar *markup;
+
+	markup = msim_convert_xml(session, raw,
+			(MSIM_XMLNODE_CONVERT)(html_tag_to_msim_markup));
+	
+	if (purple_account_get_bool(session->account, "emoticons", TRUE)) {
+		/* Frees markup and allocates a new one. */
+		markup = msim_convert_smileys_to_markup(markup);
+	}
+
+	return markup;
+}
+
+/** Get the MsimUser from a PurpleBuddy, creating it if needed. */
+static MsimUser *
+msim_get_user_from_buddy(PurpleBuddy *buddy)
+{
+	MsimUser *user;
+
+	if (!buddy) {
+		return NULL;
+	}
+
+	if (!buddy->proto_data) {
+		/* No MsimUser for this buddy; make one. */
+
+		/* TODO: where is this freed? */
+		user = g_new0(MsimUser, 1);
+		user->buddy = buddy;
+		buddy->proto_data = (gpointer)user;
+	} 
+
+	user = (MsimUser *)(buddy->proto_data);
+
+	return user;
+}
+
+/** Find and return an MsimUser * representing a user on the buddy list, or NULL. */
+static MsimUser *
+msim_find_user(MsimSession *session, const gchar *username)
+{
+	PurpleBuddy *buddy;
+	MsimUser *user;
+
+	buddy = purple_find_buddy(session->account, username);
+	if (!buddy) {
+		return NULL;
+	}
+
+	user = msim_get_user_from_buddy(buddy);
+
+	return user;
+}
+
+
+/** 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;
+	MsimUser *user;
+
+	username = msim_msg_get_string(msg, "_username");
+	cv = msim_msg_get_string(msg, "cv");
+
+	g_return_val_if_fail(username != NULL, FALSE);
+	if (!cv) {
+		/* No client version to record, don't worry about it. */
+		return FALSE;
+	}
+
+	user = msim_find_user(session, username);
+
+	if (user) {
+		user->client_cv = atol(cv);
+		ret = TRUE;
+	} else {
+		ret = FALSE;
+	}
+
+	g_free(username);
+	g_free(cv);
+
+	return ret;
+}
+
+/** Handle an incoming buddy message. */
+static gboolean
+msim_incoming_bm(MsimSession *session, MsimMessage *msg)
+{
+	guint bm;
+   
+	bm = msim_msg_get_integer(msg, "bm");
+
+	msim_incoming_bm_record_cv(session, msg);
+
+	switch (bm) {
+		case MSIM_BM_STATUS:
+			return msim_incoming_status(session, msg);
+		case MSIM_BM_INSTANT:
+			return msim_incoming_im(session, msg);
+		case MSIM_BM_ACTION:
+			return msim_incoming_action(session, msg);
+		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.
+ *
+ * @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;
+
+	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");
+	g_return_val_if_fail(username != NULL, FALSE);
+
+	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);
+
+	serv_got_im(session->gc, username, msg_purple_markup, 
+			PURPLE_MESSAGE_RECV, time(NULL));
+
+	g_free(username);
+	g_free(msg_purple_markup);
+
+	return TRUE;
+}
+
+/**
+ * Process unrecognized information.
+ *
+ * @param session
+ * @param msg An MsimMessage that was unrecognized, or NULL.
+ * @param note Information on what was unrecognized, or NULL.
+ */
+static void 
+msim_unrecognized(MsimSession *session, MsimMessage *msg, gchar *note)
+{
+	/* TODO: Some more context, outwardly equivalent to a backtrace, 
+	 * for helping figure out what this msg is for. What was going on?
+	 * But not too much information so that a user
+	 * 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). */
+
+	purple_debug_info("msim", "Unrecognized data on account for %s\n", 
+			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);
+	}
+}
+
+/** Process an incoming zap. */
+static gboolean
+msim_incoming_zap(MsimSession *session, MsimMessage *msg)
+{
+	gchar *msg_text, *username;
+	gint zap;
+	const gchar *zap_past_tense[10];
+#ifdef MSIM_USE_ATTENTION_API
+	MsimAttentionType attn;
+#else
+	gchar *zap_text;
+#endif
+
+	zap_past_tense[0] = _("zapped");
+	zap_past_tense[1] = _("whacked");
+	zap_past_tense[2] = _("torched");
+	zap_past_tense[3] = _("smooched");
+	zap_past_tense[4] = _("hugged");
+	zap_past_tense[5] = _("bslapped");
+	zap_past_tense[6] = _("goosed");
+	zap_past_tense[7] = _("hi-fived");
+	zap_past_tense[8] = _("punk'd");
+	zap_past_tense[9] = _("raspberried");
+
+	msg_text = msim_msg_get_string(msg, "msg");
+	username = msim_msg_get_string(msg, "_username");
+
+	g_return_val_if_fail(msg_text != NULL, FALSE);
+	g_return_val_if_fail(username != NULL, FALSE);
+
+	g_return_val_if_fail(sscanf(msg_text, "!!!ZAP_SEND!!!=RTE_BTN_ZAPS_%d", &zap) == 1, FALSE);
+
+	zap = CLAMP(zap, 0, sizeof(zap_past_tense) / sizeof(zap_past_tense[0]));
+
+	/* TODO:ZAP: use msim_attention_types */
+#ifdef MSIM_USE_ATTENTION_API
+	attn.incoming_description = zap_past_tense[zap];
+	attn.outgoing_description = NULL;
+	attn.icon = NULL;		/* TODO: icon */
+
+	serv_got_attention(session->gc, username, &attn, TRUE);
+#else
+	zap_text = g_strdup_printf(_("*** You have been %s! ***"), zap_past_tense[zap]);
+	serv_got_im(session->gc, username, zap_text, 
+			PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_SYSTEM, time(NULL));
+	g_free(zap_text);
+#endif
+
+	g_free(msg_text);
+	g_free(username);
+
+	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 <%d>\n", 
+			msg_text, username);
+
+	if (strcmp(msg_text, "%typing%") == 0) {
+		/* TODO: find out if msim repeatedly sends typing messages, so we can 
+		 * give it a timeout. Right now, there does seem to be an inordinately 
+		 * amount of time between typing stopped-typing notifications. */
+		serv_got_typing(session->gc, username, 0, PURPLE_TYPING);
+		rc = TRUE;
+	} else if (strcmp(msg_text, "%stoptyping%") == 0) {
+		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 {
+		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 (buddy icon) 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;
+}
+
+
+#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;
+}
+
+/** Format the "now playing" indicator, showing the artist and song.
+ * @return Return a new string (must be g_free()'d), or NULL.
+ */
+static gchar *
+msim_format_now_playing(gchar *band, gchar *song)
+{
+	if ((band && strlen(band)) || (song && strlen(song))) {
+		return g_strdup_printf("%s - %s",
+			(band && strlen(band)) ? band : "Unknown Artist",
+			(song && strlen(song)) ? song : "Unknown Song");
+	} else {
+		return NULL;
+	}
+}
+
+/** Append user information to a PurpleNotifyUserInfo, given an MsimUser. 
+ * Used by msim_tooltip_text() and msim_get_info_cb() to show a user's profile.
+ */
+static void
+msim_append_user_info(MsimSession *session, PurpleNotifyUserInfo *user_info, MsimUser *user, gboolean full)
+{
+	gchar *str;
+	guint uid;
+	guint cv;
+
+	/* Useful to identify the account the tooltip refers to. 
+	 *  Other prpls show this. */
+	if (user->username) {
+		purple_notify_user_info_add_pair(user_info, _("User"), user->username);
+	}
+
+	uid = purple_blist_node_get_int(&user->buddy->node, "UserID");
+
+	if (full) {
+		/* TODO: link to username, if available */
+		purple_notify_user_info_add_pair(user_info, _("Profile"),
+				g_strdup_printf("<a href=\"http://myspace.com/%d\">http://myspace.com/%d</a>",
+					uid, uid));
+	}
+
+
+	/* a/s/l...the vitals */
+	if (user->age) {
+		purple_notify_user_info_add_pair(user_info, _("Age"),
+				g_strdup_printf("%d", user->age));
+	}
+
+	if (user->gender && strlen(user->gender)) {
+		purple_notify_user_info_add_pair(user_info, _("Gender"), user->gender);
+	}
+
+	if (user->location && strlen(user->location)) {
+		purple_notify_user_info_add_pair(user_info, _("Location"), user->location);
+	}
+
+	/* Other information */
+	if (user->headline && strlen(user->headline)) {
+		purple_notify_user_info_add_pair(user_info, _("Headline"), user->headline);
+	}
+
+	str = msim_format_now_playing(user->band_name, user->song_name);
+	if (str && strlen(str)) {
+		purple_notify_user_info_add_pair(user_info, _("Song"), str);
+	}
+
+	/* Note: total friends only available if looked up by uid, not username. */
+	if (user->total_friends) {
+		purple_notify_user_info_add_pair(user_info, _("Total Friends"),
+			g_strdup_printf("%d", user->total_friends));
+	}
+
+	if (full) {
+		/* Client information */
+
+		str = user->client_info;
+		cv = user->client_cv;
+
+		if (str && cv != 0) {
+			purple_notify_user_info_add_pair(user_info, _("Client Version"),
+					g_strdup_printf("%s (build %d)", str, cv));
+		} else if (str) {
+			purple_notify_user_info_add_pair(user_info, _("Client Version"),
+					g_strdup(str));
+		} else if (cv) {
+			purple_notify_user_info_add_pair(user_info, _("Client Version"),
+					g_strdup_printf("Build %d", cv));
+		}
+	}
+}
+
+/** 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;
+	gboolean temporary_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");
+		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. */
+		temporary_user = TRUE;
+		user = g_new0(MsimUser, 1);
+	} else {
+		temporary_user = FALSE;
+	}
+
+	/* 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);
+	/* TODO: do not free username, since it will be used by user_info? */
+
+	if (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->band_name);
+		g_free(user->song_name);
+		g_free(user->image_url);
+		g_free(user);
+	}
+
+}
+
+/** 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;
+	guint uid;
+	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 && (uid = purple_blist_node_get_int(&user->buddy->node, "UserID"))) {
+		user_to_lookup = g_strdup_printf("%d", uid);
+	} 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;
+	MsimSession *session;
+	guint status_code;
+	const gchar *statstring;
+
+	session = (MsimSession *)account->gc->proto_data;
+
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+
+	type = purple_status_get_type(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;
+			break;
+	}
+
+	statstring = purple_status_get_attr_string(status, "message");
+
+	if (!statstring) {
+		statstring = g_strdup("");
+	}
+
+	msim_set_status_code(session, status_code, g_strdup(statstring));
+}
+
+/** Go idle. */
+void
+msim_set_idle(PurpleConnection *gc, int time)
+{
+	MsimSession *session;
+
+	g_return_if_fail(gc != NULL);
+
+	session = (MsimSession *)gc->proto_data;
+
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+
+	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 online.
+		 */
+		/* TODO: find out how to keep old status string? */
+		msim_set_status_code(session, MSIM_STATUS_CODE_ONLINE, g_strdup(""));
+	} else {
+		/* msim doesn't support idle time, so just go idle */
+		msim_set_status_code(session, MSIM_STATUS_CODE_IDLE, g_strdup(""));
+	}
+}
+
+/** 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");
+	}
+
+}
+
+/** 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);
+  
+	/* TODO: attach more useful information, like ImageURL */
+
+	msim_process(session, msg);
+
+	/* TODO: Free copy cloned from  msim_preprocess_incoming(). */
+	//XXX 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. Static string. 
+ *
+ */
+static const gchar *
+msim_uid2username_from_blist(MsimSession *session, guint wanted_uid)
+{
+	GSList *buddies, *cur;
+	gchar *ret;
+
+	buddies = purple_find_buddies(session->account, NULL); 
+
+	if (!buddies)
+	{
+		purple_debug_info("msim", "msim_uid2username_from_blist: no buddies?");
+		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 = g_strdup(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, 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;
+	gchar *errmsg;
+
+	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) {
+		errmsg = g_strdup_printf(_("Connection to server lost (no data received within %d seconds)"), (int)delta);
+
+		purple_debug_info("msim", "msim_check_alive: %s > interval of %d, presumed dead\n",
+				errmsg, MSIM_KEEPALIVE_INTERVAL);
+		purple_connection_error(session->gc, errmsg);
+
+		purple_notify_error(session->gc, NULL, errmsg, NULL);
+
+		g_free(errmsg);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+#endif
+
+/** Handle mail reply checks. */
+static void
+msim_check_inbox_cb(MsimSession *session, MsimMessage *reply, gpointer data)
+{
+	MsimMessage *body;
+	GString *notification;
+	guint old_inbox_status;
+	guint i, n;
+	const gchar *froms[5], *tos[5], *urls[5], *subjects[5];
+
+	/* Three parallel arrays for each new inbox message type. */
+	static const gchar *inbox_keys[] = 
+	{ 
+		"Mail", 
+		"BlogComment", 
+		"ProfileComment", 
+		"FriendRequest", 
+		"PictureComment" 
+	};
+
+	static const guint inbox_bits[] = 
+	{ 
+		MSIM_INBOX_MAIL, 
+		MSIM_INBOX_BLOG_COMMENT,
+		MSIM_INBOX_PROFILE_COMMENT,
+		MSIM_INBOX_FRIEND_REQUEST,
+		MSIM_INBOX_PICTURE_COMMENT
+	};
+
+	static const gchar *inbox_urls[] =
+	{
+		"http://messaging.myspace.com/index.cfm?fuseaction=mail.inbox",
+		"http://blog.myspace.com/index.cfm?fuseaction=blog",
+		"http://home.myspace.com/index.cfm?fuseaction=user",
+		"http://messaging.myspace.com/index.cfm?fuseaction=mail.friendRequests",
+		"http://home.myspace.com/index.cfm?fuseaction=user"
+	};
+
+	static const gchar *inbox_text[5];
+
+	/* Can't write _()'d strings in array initializers. Workaround. */
+	inbox_text[0] = _("New mail messages");
+	inbox_text[1] = _("New blog comments");
+	inbox_text[2] = _("New profile comments");
+	inbox_text[3] = _("New friend requests!");
+	inbox_text[4] = _("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");
+	g_return_if_fail(body != NULL);
+
+	notification = g_string_new("");
+
+	old_inbox_status = session->inbox_status;
+
+	n = 0;
+
+	for (i = 0; i < sizeof(inbox_keys) / sizeof(inbox_keys[0]); ++i) {
+		const gchar *key;
+		guint bit;
+		
+		key = inbox_keys[i];
+		bit = inbox_bits[i];
+
+		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] = inbox_text[i];
+				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] = inbox_urls[i];
+
+				++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;
+
+	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;
+}
+
+/** Called when the session key arrives. */
+static gboolean
+msim_we_are_logged_on(MsimSession *session, MsimMessage *msg)
+{
+	MsimMessage *body;
+
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != 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");
+
+	/* 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");
+
+	/* 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);
+
+
+	/* Additional post-connect operations */
+
+
+	if (msim_msg_get_integer(msg, "uniquenick") == session->userid) {
+		purple_debug_info("msim_we_are_logged_on", "TODO: pick 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
+
+	purple_timeout_add(MSIM_MAIL_INTERVAL_CHECK, 
+			(GSourceFunc)msim_check_inbox, session);
+
+	msim_check_inbox(session);
+
+	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);
+
+#ifdef MSIM_DEBUG_MSG
+	msim_msg_dump("ready to process: %s\n", msg);
+#endif
+
+	if (msim_msg_get_integer(msg, "lc") == 1) {
+		return msim_login_challenge(session, msg);
+	} else if (msim_msg_get_integer(msg, "lc") == 2) {
+		return msim_we_are_logged_on(session, msg);
+	} else if (msim_msg_get(msg, "bm"))  {
+		return msim_incoming_bm(session, msg);
+	} else if (msim_msg_get(msg, "rid")) {
+		return msim_process_reply(session, msg);
+	} else if (msim_msg_get(msg, "error")) {
+		return msim_error(session, msg);
+	} else if (msim_msg_get(msg, "ka")) {
+		return TRUE;
+	} else {
+		msim_unrecognized(session, msg, "in msim_process");
+		return FALSE;
+	}
+}
+
+/** Callback for when a buddy icon finished being downloaded. */
+static void
+msim_downloaded_buddy_icon(PurpleUtilFetchUrlData *url_data,
+		gpointer user_data,
+		const gchar *url_text,
+		gsize len,
+		const gchar *error_message)
+{
+	MsimUser *user;
+
+	user = (MsimUser *)user_data;
+
+	purple_debug_info("msim_downloaded_buddy_icon",
+			"Downloaded %d bytes\n", len);
+
+	purple_buddy_icons_set_for_user(user->buddy->account,
+			user->buddy->name,
+			(gchar *)url_text, len, 
+			/*  Use URL itself as buddy icon "checksum" */
+			user->image_url);
+}
+
+/** Store a field of information about a buddy. */
+static void 
+msim_store_user_info_each(const gchar *key_str, gchar *value_str, MsimUser *user)
+{
+	if (!strcmp(key_str, "UserID") || !strcmp(key_str, "ContactID")) {
+		/* Save to buddy list, if it exists, for quick cached uid lookup with msim_uid2username_from_blist(). */
+		if (user->buddy)
+		{
+			purple_debug_info("msim", "associating uid %s with username %s\n", key_str, user->buddy->name);
+			purple_blist_node_set_int(&user->buddy->node, "UserID", atol(value_str));
+		}
+		/* Need to store in MsimUser, too? What if not on blist? */
+	} else if (!strcmp(key_str, "Age")) {
+		user->age = atol(value_str);
+	} else if (!strcmp(key_str, "Gender")) {
+		user->gender = g_strdup(value_str);
+	} else if (!strcmp(key_str, "Location")) {
+		user->location = g_strdup(value_str);
+	} else if (!strcmp(key_str, "TotalFriends")) {
+		user->total_friends = atol(value_str);
+	} else if (!strcmp(key_str, "DisplayName")) {
+		user->display_name = g_strdup(value_str);
+	} else if (!strcmp(key_str, "BandName")) {
+		user->band_name = g_strdup(value_str);
+	} else if (!strcmp(key_str, "SongName")) {
+		user->song_name = g_strdup(value_str);
+	} else if (!strcmp(key_str, "UserName") || !strcmp(key_str, "IMName") || !strcmp(key_str, "NickName")) {
+		/* Ignore because PurpleBuddy knows this already */
+		;
+	} else if (!strcmp(key_str, "ImageURL") || !strcmp(key_str, "AvatarURL")) {
+		const gchar *previous_url;
+
+		user->image_url = g_strdup(value_str);
+		
+		previous_url = purple_buddy_icons_get_checksum_for_user(user->buddy);
+
+		/* Only download if URL changed */
+		if (!previous_url || strcmp(previous_url, user->image_url)) {
+			purple_util_fetch_url(user->image_url, TRUE, NULL, TRUE, msim_downloaded_buddy_icon, (gpointer)user);
+		}
+	} else if (!strcmp(key_str, "Headline")) {
+		user->headline = g_strdup(value_str);
+	} else {
+		/* TODO: other fields in MsimUser */
+		gchar *msg;
+
+		msg = g_strdup_printf("msim_store_user_info_each: unknown field %s=%s",
+				key_str, value_str);
+
+		msim_unrecognized(NULL, NULL, msg);
+
+		g_free(msg);
+	}
+}
+
+/** Save buddy information to the buddy list from a user info reply message.
+ *
+ * @param session
+ * @param msg The user information reply, with any amount of information.
+ * @param user The structure to save to, or NULL to save in PurpleBuddy->proto_data.
+ *
+ * Variable information is saved to the passed MsimUser structure. Permanent
+ * information (UserID) is stored in the blist node of the buddy list (and
+ * ends up in blist.xml, persisted to disk) if it exists.
+ *
+ * If the function has no buddy information, this function
+ * is a no-op (and returns FALSE).
+ *
+ */
+static gboolean 
+msim_store_user_info(MsimSession *session, MsimMessage *msg, MsimUser *user)
+{
+	gchar *username;
+	MsimMessage *body, *body_node;
+
+	g_return_val_if_fail(MSIM_SESSION_VALID(session), FALSE);
+	g_return_val_if_fail(msg != NULL, FALSE);
+
+	body = msim_msg_get_dictionary(msg, "body");
+	if (!body) {
+		return FALSE;
+	}
+
+	username = msim_msg_get_string(body, "UserName");
+
+	if (!username) {
+		purple_debug_info("msim", 
+			"msim_process_reply: not caching body, no UserName\n");
+		msim_msg_free(body);
+		g_free(username);
+		return FALSE;
+	}
+	
+	/* Null user = find and store in PurpleBuddy's proto_data */
+	if (!user) {
+		user = msim_find_user(session, username);
+		if (!user) {
+			msim_msg_free(body);
+			g_free(username);
+			return FALSE;
+		}
+	}
+
+	/* TODO: make looping over MsimMessage's easier. */
+	for (body_node = body; 
+		body_node != NULL; 
+		body_node = msim_msg_get_next_element_node(body_node))
+	{
+		const gchar *key_str;
+		gchar *value_str;
+		MsimMessageElement *elem;
+
+		elem = (MsimMessageElement *)body_node->data;
+		key_str = elem->name;
+
+		value_str = msim_msg_get_string_from_element(elem);
+		msim_store_user_info_each(key_str, value_str, user);
+		g_free(value_str);
+	}
+
+	if (msim_msg_get_integer(msg, "dsn") == MG_OWN_IM_INFO_DSN &&
+		msim_msg_get_integer(msg, "lid") == MG_OWN_IM_INFO_LID) {
+		/* TODO: do something with our own IM info, if we need it for some
+		 * specific purpose. Otherwise it is available on the buddy list,
+		 * if the user has themselves as their own buddy. 
+		 *
+		 * However, much of the info is already available in MsimSession,
+		 * stored in msim_we_are_logged_on(). */
+	} else if (msim_msg_get_integer(msg, "dsn") == MG_OWN_MYSPACE_INFO_DSN &&
+			msim_msg_get_integer(msg, "lid") == MG_OWN_MYSPACE_INFO_LID) {
+		/* TODO: same as above, but for MySpace info. */
+	}
+
+	msim_msg_free(body);
+
+	return TRUE;
+}
+
+/** Process the initial server information from the server. */
+static gboolean
+msim_process_server_info(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 */
+	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);
+
+	rid = msim_msg_get_integer(msg, "rid");
+	cmd = msim_msg_get_integer(msg, "cmd");
+	dsn = msim_msg_get_integer(msg, "dsn");
+	lid = msim_msg_get_integer(msg, "lid");
+
+	/* Unsolicited messages */
+	if (cmd == (MSIM_CMD_BIT_REPLY | MSIM_CMD_GET)) {
+		if (dsn == MG_SERVER_INFO_DSN && lid == MG_SERVER_INFO_LID) {
+			return msim_process_server_info(session, msg);
+		} else if (dsn == MG_WEB_CHALLENGE_DSN && lid == MG_WEB_CHALLENGE_LID) {
+			return msim_web_challenge(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);
+
+	purple_notify_error(session->account, g_strdup(_("MySpaceIM Error")), 
+			full_errmsg, NULL);
+
+	/* Destroy session if fatal. */
+	if (msim_msg_get(msg, "fatal")) {
+		purple_debug_info("msim", "fatal error, closing\n");
+		purple_connection_error(session->gc, 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;
+	gint status_code, purple_status_code;
+	gchar *username;
+
+	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 = atoi(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 = g_list_nth_data(list, MSIM_STATUS_ORDINAL_HEADLINE);
+
+	blist = purple_get_blist();
+
+	/* Add buddy if not found */
+	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);
+
+		/* All buddies on list should have 'uid' integer associated with them. */
+		purple_blist_node_set_int(&buddy->node, "UserID", msim_msg_get_integer(msg, "f"));
+		
+		msim_store_user_info(session, msg, NULL);
+	} else {
+		purple_debug_info("msim", "msim_status: found buddy %s\n", username);
+	}
+
+	user->headline = g_strdup(status_headline);
+  
+	/* 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:
+			/* will be handled below */
+			purple_status_code = -1;
+			break;
+
+		default:
+				purple_debug_info("msim", "msim_status for %s, unknown status code %d, treating as available\n",
+						username, status_code);
+				purple_status_code = PURPLE_STATUS_AVAILABLE;
+	}
+
+	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
+
+	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. */
+
+#if 0
+	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,
+		"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);
+#endif
+
+}
+
+/** 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)
+{
+	msim_msg_dump("msim_do_postprocessing msg: %s\n", msg);
+
+	/* First, check - if the field already exists, replace <uid> within it */
+	if (msim_msg_get(msg, uid_field_name)) {
+		MsimMessageElement *elem;
+		gchar *fmt_string;
+		gchar *uid_str, *new_str;
+
+		/* Warning: this is a delicate, but safe, operation */
+
+		elem = msim_msg_get(msg, uid_field_name);
+
+		/* 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 = str_replace(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;
+	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);
+
+	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);
+	//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;
+		}
+
+		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);
+
+	//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);
+}
+
+/** 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 gc_uncasted A PurpleConnection pointer.
+ * @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;
+	gchar *end;
+	int n;
+
+	g_return_if_fail(gc_uncasted != NULL);
+	g_return_if_fail(source >= 0);  /* Note: 0 is a valid fd */
+
+	gc = (PurpleConnection *)(gc_uncasted);
+	account = purple_connection_get_account(gc);
+	session = gc->proto_data;
+
+	/* libpurple/eventloop.h only defines these two */
+	if (cond != PURPLE_INPUT_READ && cond != PURPLE_INPUT_WRITE) {
+		purple_debug_info("msim_input_cb", "unknown condition=%d\n", cond);
+		purple_connection_error(gc, _("Invalid input condition"));
+		return;
+	}
+
+	g_return_if_fail(cond == PURPLE_INPUT_READ);
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+
+	/* Mark down that we got data, so don't timeout. */
+	session->last_comm = time(NULL);
+
+	/* Only can handle so much data at once... 
+	 * If this happens, try recompiling with a higher MSIM_READ_BUF_SIZE.
+	 * Should be large enough to hold the largest protocol message.
+	 */
+	if (session->rxoff >= MSIM_READ_BUF_SIZE) {
+		purple_debug_error("msim", 
+				"msim_input_cb: %d-byte read buffer full! rxoff=%d\n",
+				MSIM_READ_BUF_SIZE, session->rxoff);
+		purple_connection_error(gc, _("Read buffer full"));
+		return;
+	}
+
+	purple_debug_info("msim", "buffer at %d (max %d), reading up to %d\n",
+			session->rxoff, MSIM_READ_BUF_SIZE, 
+			MSIM_READ_BUF_SIZE - session->rxoff);
+
+	/* 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, MSIM_READ_BUF_SIZE - session->rxoff, 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, strerror(errno), source, session->fd, session->fd);
+		purple_connection_error(gc, _("Read error"));
+		return;
+	} else if (n == 0) {
+		purple_debug_info("msim", "msim_input_cb: server disconnected\n");
+		purple_connection_error(gc, _("Server has disconnected"));
+		return;
+	}
+
+	if (n + session->rxoff >= MSIM_READ_BUF_SIZE) {
+		purple_debug_info("msim_input_cb", "received %d bytes, pushing rxoff to %d, over buffer size of %d\n",
+				n, n + session->rxoff, MSIM_READ_BUF_SIZE);
+		/* TODO: g_realloc like msn, yahoo, irc, jabber? */
+		purple_connection_error(gc, _("Read buffer full"));
+	}
+
+	/* Null terminate */
+	purple_debug_info("msim", "msim_input_cb: going to null terminate "
+			"at n=%d\n", n);
+	session->rxbuf[session->rxoff + n] = 0;
+
+#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(gc, "Invalid message - null byte on input");
+		return;
+	}
+#endif
+
+	session->rxoff += n;
+	purple_debug_info("msim", "msim_input_cb: read=%d\n", n);
+
+#ifdef MSIM_DEBUG_RXBUF
+	purple_debug_info("msim", "buf=<%s>\n", session->rxbuf);
+#endif
+
+	/* Look for \\final\\ end markers. If found, process message. */
+	while((end = strstr(session->rxbuf, MSIM_FINAL_STRING))) {
+		MsimMessage *msg;
+
+#ifdef MSIM_DEBUG_RXBUF
+		purple_debug_info("msim", "in loop: buf=<%s>\n", session->rxbuf);
+#endif
+		*end = 0;
+		msg = msim_parse(g_strdup(session->rxbuf));
+		if (!msg) {
+			purple_debug_info("msim", "msim_input_cb: couldn't parse rxbuf\n");
+			purple_connection_error(gc, _("Unparseable message"));
+		} else {
+			/* Process message and then free it (processing function should
+			 * clone message if it wants to keep it afterwards.) */
+			if (!msim_preprocess_incoming(session, msg)) {
+				msim_msg_dump("msim_input_cb: preprocessing message failed on msg: %s\n", msg);
+			}
+			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), 
+				MSIM_READ_BUF_SIZE - (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?
+ */
+static 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;
+
+	g_return_if_fail(data != NULL);
+
+	gc = (PurpleConnection *)data;
+	session = (MsimSession *)gc->proto_data;
+
+	if (source < 0) {
+		purple_connection_error(gc, _("Couldn't connect to host"));
+		purple_connection_error(gc, 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);
+}
+
+/* Session methods */
+
+/**
+ * Create a new MSIM session.
+ *
+ * @param acct The account to create the session from.
+ *
+ * @return Pointer to a new session. Free with msim_session_destroy.
+ */
+MsimSession *
+msim_session_new(PurpleAccount *acct)
+{
+	MsimSession *session;
+
+	g_return_val_if_fail(acct != NULL, NULL);
+
+	session = g_new0(MsimSession, 1);
+
+	session->magic = MSIM_SESSION_STRUCT_MAGIC;
+	session->account = acct;
+	session->gc = purple_account_get_connection(acct);
+	session->sesskey = 0;
+	session->userid = 0;
+	session->username = NULL;
+	session->fd = -1;
+
+	/* TODO: Remove. */
+	session->user_lookup_cb = g_hash_table_new_full(g_direct_hash, 
+			g_direct_equal, NULL, NULL);  /* do NOT free function pointers! (values) */
+	session->user_lookup_cb_data = g_hash_table_new_full(g_direct_hash, 
+			g_direct_equal, NULL, NULL);/* TODO: we don't know what the values are,
+											 they could be integers inside gpointers
+											 or strings, so I don't freed them.
+											 Figure this out, once free cache. */
+
+	/* Created in msim_process_server_info() */
+	session->server_info = NULL;
+
+	session->rxoff = 0;
+	session->rxbuf = g_new0(gchar, MSIM_READ_BUF_SIZE);
+	session->next_rid = 1;
+	session->last_comm = time(NULL);
+	session->inbox_status = 0;
+	
+	return session;
+}
+
+/**
+ * Free a session.
+ *
+ * @param session The session to destroy.
+ */
+void 
+msim_session_destroy(MsimSession *session)
+{
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	
+	session->magic = -1;
+
+	g_free(session->rxbuf);
+	g_free(session->username);
+
+	/* TODO: Remove. */
+	g_hash_table_destroy(session->user_lookup_cb);
+	g_hash_table_destroy(session->user_lookup_cb_data);
+
+	if (session->server_info) {
+		msim_msg_free(session->server_info);
+	}
+	
+	g_free(session);
+}
+				 
+/** 
+ * Close the connection.
+ * 
+ * @param gc The connection.
+ */
+void 
+msim_close(PurpleConnection *gc)
+{
+	MsimSession *session;
+
+	if (gc == NULL) {
+		return;
+	}
+
+	session = (MsimSession *)gc->proto_data;
+	if (session == NULL)
+		return;
+
+	gc->proto_data = NULL;
+
+	if (!MSIM_SESSION_VALID(session)) {
+		return;
+	}
+
+	if (session->gc->inpa) {
+		purple_input_remove(session->gc->inpa);
+	}
+
+	msim_session_destroy(session);
+}
+
+
+/**
+ * Check if a string is a userid (all numeric).
+ *
+ * @param user The user id, email, or name.
+ *
+ * @return TRUE if is userid, FALSE if not.
+ */
+static gboolean 
+msim_is_userid(const gchar *user)
+{
+	g_return_val_if_fail(user != NULL, FALSE);
+
+	return strspn(user, "0123456789") == strlen(user);
+}
+
+/**
+ * Check if a string is an email address (contains an @).
+ *
+ * @param user The user id, email, or name.
+ *
+ * @return TRUE if is an email, FALSE if not.
+ *
+ * This function is not intended to be used as a generic
+ * means of validating email addresses, but to distinguish
+ * between a user represented by an email address from
+ * other forms of identification.
+ */ 
+static gboolean 
+msim_is_email(const gchar *user)
+{
+	g_return_val_if_fail(user != NULL, FALSE);
+
+	return strchr(user, '@') != NULL;
+}
+
+
+/**
+ * Asynchronously lookup user information, calling callback when receive result.
+ *
+ * @param session
+ * @param user The user id, email address, or username. Not freed.
+ * @param cb Callback, called with user information when available.
+ * @param data An arbitray data pointer passed to the callback.
+ */
+/* TODO: change to not use callbacks */
+static void 
+msim_lookup_user(MsimSession *session, const gchar *user, 
+		MSIM_USER_LOOKUP_CB cb, gpointer data)
+{
+	MsimMessage *body;
+	gchar *field_name;
+	guint rid, cmd, dsn, lid;
+
+	g_return_if_fail(MSIM_SESSION_VALID(session));
+	g_return_if_fail(user != NULL);
+	g_return_if_fail(cb != NULL);
+
+	purple_debug_info("msim", "msim_lookup_userid: "
+			"asynchronously looking up <%s>\n", user);
+
+	msim_msg_dump("msim_lookup_user: data=%s\n", (MsimMessage *)data);
+
+	/* Setup callback. Response will be associated with request using 'rid'. */
+	rid = msim_new_reply_callback(session, cb, data);
+
+	/* Send request */
+
+	cmd = MSIM_CMD_GET;
+
+	if (msim_is_userid(user)) {
+		field_name = "UserID";
+		dsn = MG_MYSPACE_INFO_BY_ID_DSN; 
+		lid = MG_MYSPACE_INFO_BY_ID_LID; 
+	} else if (msim_is_email(user)) {
+		field_name = "Email";
+		dsn = MG_MYSPACE_INFO_BY_STRING_DSN;
+		lid = MG_MYSPACE_INFO_BY_STRING_LID;
+	} else {
+		field_name = "UserName";
+		dsn = MG_MYSPACE_INFO_BY_STRING_DSN;
+		lid = MG_MYSPACE_INFO_BY_STRING_LID;
+	}
+
+	body = msim_msg_new(
+			field_name, MSIM_TYPE_STRING, g_strdup(user),
+			NULL);
+
+	g_return_if_fail(msim_send(session,
+			"persist", MSIM_TYPE_INTEGER, 1,
+			"sesskey", MSIM_TYPE_INTEGER, session->sesskey,
+			"cmd", MSIM_TYPE_INTEGER, 1,
+			"dsn", MSIM_TYPE_INTEGER, dsn,
+			"uid", MSIM_TYPE_INTEGER, session->userid,
+			"lid", MSIM_TYPE_INTEGER, lid,
+			"rid", MSIM_TYPE_INTEGER, rid,
+			"body", MSIM_TYPE_DICTIONARY, body,
+			NULL));
+} 
+
+
+/**
+ * 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.
+ *
+ */
+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_display_name", TRUE)) {
+		display_name = user->display_name;
+	} 
+
+	if (purple_account_get_bool(session->account, "show_headline", FALSE)) {
+		headline = user->headline;
+	}
+
+	/* 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.
+ *
+ */
+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);
+	}
+}
+
+/** 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=%X\n", contact_info);
+	uid = msim_msg_get_integer(contact_info, "ContactID");
+
+	if (!user_lookup_info) {
+		username = g_strdup(msim_uid2username_from_blist(session, 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 = purple_group_new(group_name);
+		g_free(group_name);
+	} else {
+		group = purple_group_new(_("IM Friends"));
+	}
+
+	/* 2. Get or create buddy */
+	buddy = purple_find_buddy(session->account, username);
+	if (!buddy) {
+		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);
+
+	/* All buddies on list should have 'uid' integer associated with them. */
+	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);
+}
+
+/** 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 void 
+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_if_fail(uid != 0);
+
+	/* Lookup the username, since NickName and IMName is unreliable */
+	username = msim_uid2username_from_blist(session, uid);
+	if (!username) {
+		gchar *uid_str;
+
+		uid_str = g_strdup_printf("%d", uid);
+		purple_debug_info("msim_add_contact_from_server",
+				"contact_info addr=%X\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));
+	}
+}
+
+/** 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;
+
+	msim_msg_dump("msim_got_contact_list: reply=%s", reply);
+
+	body = msim_msg_get_dictionary(reply, "body");
+	g_return_if_fail(body != NULL);
+
+	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 (!strcmp(elem->name, "ContactID"))
+		{
+			/* Will look for first contact in body_node */
+			msim_add_contact_from_server(session, body_node);
+		}
+	}
+
+	msim_msg_free(body);
+}
+
+/** 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 (strcmp(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");
+
+	g_return_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_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, NULL),
+			"body", MSIM_TYPE_STRING, g_strdup(""),
+			NULL));
+
+	/* 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. */
+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(g_strdup_printf("%s",
+				_("Add friends from MySpace.com")), msim_import_friends);
+	menu = g_list_append(menu, act);
+
+	return menu;
+}
+
+/** Callbacks called by Purple, to access this plugin. */
+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 */
+	msim_status_text,  /* status_text */
+	msim_tooltip_text, /* tooltip_text */
+	msim_status_types, /* status_types */
+	msim_blist_node_menu,  /* blist_node_menu */
+	NULL,              /* chat_info */
+	NULL,              /* chat_info_defaults */
+	msim_login,        /* login */
+	msim_close,        /* close */
+	msim_send_im,      /* send_im */
+	NULL,              /* set_info */
+	msim_send_typing,  /* send_typing */
+	msim_get_info,     /* get_info */
+	msim_set_status,   /* set_status */
+	msim_set_idle,     /* set_idle */
+	NULL,              /* change_passwd */
+	msim_add_buddy,    /* add_buddy */
+	NULL,              /* add_buddies */
+	msim_remove_buddy, /* remove_buddy */
+	NULL,              /* remove_buddies */
+	NULL,              /* add_permit */
+	NULL,              /* add_deny */
+	NULL,              /* rem_permit */
+	NULL,              /* rem_deny */
+	NULL,              /* set_permit_deny */
+	NULL,              /* join_chat */
+	NULL,              /* reject chat invite */
+	NULL,              /* get_chat_name */
+	NULL,              /* chat_invite */
+	NULL,              /* chat_leave */
+	NULL,              /* chat_whisper */
+	NULL,              /* chat_send */
+	NULL,              /* keepalive */
+	NULL,              /* register_user */
+	NULL,              /* get_cb_info */
+	NULL,              /* get_cb_away */
+	NULL,              /* alias_buddy */
+	NULL,              /* group_buddy */
+	NULL,              /* rename_group */
+	NULL,              /* buddy_free */
+	NULL,              /* convo_closed */
+	NULL,              /* normalize */
+	NULL,              /* set_buddy_icon */
+	NULL,              /* remove_group */
+	NULL,              /* get_cb_real_name */
+	NULL,              /* set_chat_topic */
+	NULL,              /* find_blist_chat */
+	NULL,              /* roomlist_get_list */
+	NULL,              /* roomlist_cancel */
+	NULL,              /* roomlist_expand_category */
+	NULL,              /* can_receive_file */
+	NULL,              /* send_file */
+	NULL,              /* new_xfer */
+	msim_offline_message,  /* offline_message */
+	NULL,              /* whiteboard_prpl_ops */
+	msim_send_really_raw,  /* send_raw */
+	NULL,                  /* roomlist_room_serialize */
+#ifdef MSIM_USE_ATTENTION_API
+	msim_send_attention,   /* send_attention */
+	msim_attention_types,  /* attention_types */
+#else
+	NULL,               /* _purple_reserved1 */
+	NULL,               /* _purple_reserved2 */
+#endif
+	NULL,               /* _purple_reserved3 */
+	NULL                /* _purple_reserved4 */
+};
+
+
+
+/** Based on MSN's plugin info comments. */
+PurplePluginInfo info = {
+	PURPLE_PLUGIN_MAGIC,                                
+	PURPLE_MAJOR_VERSION,
+	PURPLE_MINOR_VERSION,
+	PURPLE_PLUGIN_PROTOCOL,                           /**< type           */
+	NULL,                                             /**< ui_requirement */
+	0,                                                /**< flags          */
+	NULL,                                             /**< dependencies   */
+	PURPLE_PRIORITY_DEFAULT,                          /**< priority       */
+
+	"prpl-myspace",                                   /**< id             */
+	"MySpaceIM",                                      /**< name           */
+	MSIM_PRPL_VERSION_STRING,                         /**< version        */
+	                                                  /**  summary        */
+	"MySpaceIM Protocol Plugin",
+	                                                  /**  description    */
+	"MySpaceIM Protocol Plugin",
+	"Jeff Connelly <[e-mail]>",            /**< author         */
+	"http://developer.pidgin.im/wiki/MySpaceIM/",     /**< homepage       */
+
+	msim_load,                                        /**< load           */
+	NULL,                                             /**< unload         */
+	NULL,                                             /**< destroy        */
+	NULL,                                             /**< ui_info        */
+	&prpl_info,                                       /**< extra_info     */
+	NULL,                                             /**< prefs_info     */
+	msim_actions,                                     /**< msim_actions   */
+	NULL,                                             /**< reserved1      */
+	NULL,                                             /**< reserved2      */
+	NULL,                                             /**< reserved3      */
+	NULL                                              /**< reserved4      */
+};
+
+
+#ifdef MSIM_SELF_TEST
+/** 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;
+
+
+	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;
+	guint failures;
+
+	failures = 0;
+
+	purple_debug_info("msim", "\n\nTesting MsimMessage\n");
+	msg = msim_msg_new(NULL);      /* Create a new, empty message. */
+
+	/* Append some new elements. */
+	msg = msim_msg_append(msg, "bx", MSIM_TYPE_BINARY, g_string_new_len(g_strdup("XXX"), 3));
+	msg = msim_msg_append(msg, "k1", MSIM_TYPE_STRING, g_strdup("v1"));
+	msg = msim_msg_append(msg, "k1", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(42));
+	msg = msim_msg_append(msg, "k1", MSIM_TYPE_STRING, g_strdup("v43"));
+	msg = msim_msg_append(msg, "k1", MSIM_TYPE_STRING, g_strdup("v52/xxx\\yyy"));
+	msg = msim_msg_append(msg, "k1", MSIM_TYPE_STRING, g_strdup("v7"));
+	msim_msg_dump("msg debug str=%s\n", msg);
+	packed = msim_msg_pack(msg);
+
+	purple_debug_info("msim", "msg packed=%s\n", packed);
+
+	packed_expected = "\\bx\\WFhY\\k1\\v1\\k1\\42\\k1"
+		"\\v43\\k1\\v52/1xxx/2yyy\\k1\\v7\\final\\";
+
+	if (0 != strcmp(packed, packed_expected)) {
+		purple_debug_info("msim", "!!!(%d), msim_msg_pack not what expected: %s != %s\n",
+				++failures, packed, packed_expected);
+	}
+
+
+	msg_cloned = msim_msg_clone(msg);
+	packed_cloned = msim_msg_pack(msg_cloned);
+
+	purple_debug_info("msim", "msg cloned=%s\n", packed_cloned);
+	if (0 != strcmp(packed, packed_cloned)) {
+		purple_debug_info("msim", "!!!(%d), msim_msg_pack on cloned message not equal to original: %s != %s\n",
+				++failures, packed_cloned, packed);
+	}
+
+	g_free(packed);
+	g_free(packed_cloned);
+	msim_msg_free(msg_cloned);
+	msim_msg_free(msg);
+
+	/* Try some of the more advanced functionality */
+	list = NULL;
+
+	list = g_list_prepend(list, "item3");
+	list = g_list_prepend(list, "item2");
+	list = g_list_prepend(list, "item1");
+	list = g_list_prepend(list, "item0");
+
+	msg = msim_msg_new(NULL);
+	msg = msim_msg_append(msg, "string", MSIM_TYPE_STRING, g_strdup("string value"));
+	msg = msim_msg_append(msg, "raw", MSIM_TYPE_RAW, g_strdup("raw value"));
+	msg = msim_msg_append(msg, "integer", MSIM_TYPE_INTEGER, GUINT_TO_POINTER(3140));
+	msg = msim_msg_append(msg, "boolean", MSIM_TYPE_BOOLEAN, GUINT_TO_POINTER(FALSE));
+	msg = msim_msg_append(msg, "list", MSIM_TYPE_LIST, list);
+
+	msim_msg_dump("msg with list=%s\n", msg);
+	purple_debug_info("msim", "msg with list packed=%s\n", msim_msg_pack(msg));
+
+	msg2 = msim_msg_new(NULL);
+	msg2 = msim_msg_append(msg2, "outer", MSIM_TYPE_STRING, g_strdup("outer value"));
+	msg2 = msim_msg_append(msg2, "body", MSIM_TYPE_DICTIONARY, msg);
+	msim_msg_dump("msg with dict=%s\n", msg2);      /* msg2 now 'owns' msg */
+	purple_debug_info("msim", "msg with dict packed=%s\n", msim_msg_pack(msg2));
+
+	msim_msg_free(msg2);
+
+	return failures;
+}
+
+/** Test protocol-level escaping/unescaping. */
+int 
+msim_test_escaping(void)
+{
+	guint failures;
+	gchar *raw, *escaped, *unescaped, *expected;
+
+	failures = 0;
+
+	purple_debug_info("msim", "\n\nTesting escaping\n");
+
+	raw = "hello/world\\hello/world";
+
+	escaped = msim_escape(raw);
+	purple_debug_info("msim", "msim_test_escaping: raw=%s, escaped=%s\n", raw, escaped);
+	expected = "hello/1world/2hello/1world";
+	if (0 != strcmp(escaped, expected)) {
+		purple_debug_info("msim", "!!!(%d), msim_escape failed: %s != %s\n",
+				++failures, escaped, expected);
+	}
+
+
+	unescaped = msim_unescape(escaped);
+	g_free(escaped);
+	purple_debug_info("msim", "msim_test_escaping: unescaped=%s\n", unescaped);
+	if (0 != strcmp(raw, unescaped)) {
+		purple_debug_info("msim", "!!!(%d), msim_unescape failed: %s != %s\n",
+				++failures, raw, unescaped);
+	}
+
+	return failures;
+}
+#endif
+
+/** Initialize plugin. */
+void 
+init_plugin(PurplePlugin *plugin) 
+{
+	PurpleAccountOption *option;
+#ifdef MSIM_SELF_TEST
+	msim_test_all();
+	exit(0);
+#endif /* MSIM_SELF_TEST */
+
+
+	/* TODO: default to automatically try different ports. Make the user be
+	 * able to set the first port to try (like LastConnectedPort in Windows client).  */
+	option = purple_account_option_string_new(_("Connect server"), "server", MSIM_SERVER);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+
+	option = purple_account_option_int_new(_("Connect port"), "port", MSIM_PORT);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+
+#ifdef MSIM_USER_WANTS_TO_CONFIGURE_STATUS_TEXT
+	option = purple_account_option_bool_new(_("Show display name in status text"), "show_display_name", TRUE);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+
+	option = purple_account_option_bool_new(_("Show headline in status text"), "show_headline", TRUE);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+#endif
+
+#ifdef MSIM_USER_WANTS_TO_DISABLE_EMOTICONS
+	option = purple_account_option_bool_new(_("Send emoticons"), "emoticons", FALSE);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+#endif
+
+#ifdef MSIM_USER_REALLY_CARES_ABOUT_PRECISE_FONT_SIZES
+	option = purple_account_option_int_new(_("Screen resolution (dots per inch)"), "dpi", MSIM_DEFAULT_DPI);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+
+	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
+
+	/* TODO: /zap command. Problem with this is that there are different kinds of zaps,
+	 * and the selection is best made available in a drop-down menu, instead of forcing
+	 * the user to type the kind of zap and memorizing available zaps (or putting it in the
+	 * help menu). A new "attention" API, for zap/buzz/nudge (different protocols) will
+	 * solve this. */
+#if 0
+	purple_cmd_register("zap",                                        /* cmd */
+			"w",                                              /* args - accept a single word */
+			PURPLE_CMD_P_PRPL,                                /* priority */
+			PURPLE_CMD_FLAG_IM | PURPLE_CMD_FLAG_PRPL_ONLY,   /* flags */
+			"prpl-myspace",                                   /* prpl_id */
+			msim_cmd_zap,                                     /* func */
+			_("zap: zap a user to get their attention"),      /* helpstr */
+			NULL);                                            /* data */
+#endif
+}
+
+PURPLE_INIT_PLUGIN(myspace, init_plugin, info);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/myspace.h	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,303 @@
+/* MySpaceIM Protocol Plugin, header file
+ *
+ * Copyright (C) 2007, Jeff Connelly <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MYSPACE_MYSPACE_H
+#define _MYSPACE_MYSPACE_H
+
+/* Other includes */
+#include <string.h>
+#include <errno.h>/* for EAGAIN */
+#include <stdarg.h>
+#include <math.h>
+
+#include <glib.h>
+
+#ifdef _WIN32
+#include "win32dep.h"
+#else
+/* For recv() and send(); needed to match Win32 */
+#include <sys/types.h>
+#include <sys/socket.h>
+#endif
+
+#include "internal.h"
+
+#include "notify.h"
+#include "plugin.h"
+#include "accountopt.h"
+#include "version.h"
+#include "cipher.h"     /* for SHA-1 */
+#include "util.h"       /* for base64 */
+#include "debug.h"      /* for purple_debug_info */
+#include "xmlnode.h"
+
+/* MySpaceIM includes */
+#include "message.h"
+
+/* Conditional compilation options */
+/* Send third-party client version? (Recognized by us and Miranda's plugin) */
+/*#define MSIM_SEND_CLIENT_VERSION              */
+
+/* Debugging options */
+/*#define MSIM_DEBUG_MSG                */
+/* Low-level and rarely needed */
+/*#define MSIM_DEBUG_PARSE             */
+/*#define MSIM_DEBUG_LOGIN_CHALLENGE*/
+/*#define MSIM_DEBUG_RXBUF            */
+
+/* Define to cause init_plugin() to run some tests and print
+ * the results to the Purple debug log, then exit. Useful to 
+ * run with 'pidgin -d' to see the output. Don't define if
+ * you want to actually use the plugin! */
+/*#define MSIM_SELF_TEST            */
+
+/* Use the attention API for zaps? */
+/* Can't have until >=2.2.0, since is a new API. */
+/*#define MSIM_USE_ATTENTION_API 	 */
+
+/* Constants */
+
+/* Maximum length of a password that is acceptable. This is the limit
+ * on the official client (build 679) and on the 'new password' field at
+ * http://settings.myspace.com/index.cfm?fuseaction=user.changepassword
+ * (though curiously, not on the 'current password' field). */
+
+/* Not defined; instead have the client reject the password, until libpurple
+ * supports specifying a length limit on the protocol's password. */
+/* #define MSIM_MAX_PASSWORD_LENGTH    10	*/
+
+/* Build version of MySpaceIM to report to servers (1.0.xxx.0) */
+#define MSIM_CLIENT_VERSION         697
+
+/* Language codes from http://www.microsoft.com/globaldev/reference/oslocversion.mspx */
+#define MSIM_LANGUAGE_ID_ENGLISH    1033
+#define MSIM_LANGUAGE_NAME_ENGLISH  "ENGLISH"
+
+/* msimprpl version string of this plugin */
+#define MSIM_PRPL_VERSION_STRING    "0.14"
+
+/* Default server */
+#define MSIM_SERVER                 "im.myspace.akadns.net"
+#define MSIM_PORT                   1863        /* TODO: alternate ports and automatic */
+
+/* Time between keepalives (seconds) - if no data within this time, is dead. */
+#define MSIM_KEEPALIVE_INTERVAL     (3 * 60)
+
+/* Time to check if alive (milliseconds) */
+#define MSIM_KEEPALIVE_INTERVAL_CHECK   (30 * 1000)
+
+/* Time to check for new mail (milliseconds) */
+#define MSIM_MAIL_INTERVAL_CHECK    (60 * 1000) 
+
+
+/* Constants */
+#define HASH_SIZE                   0x14        /**< Size of SHA-1 hash for login */
+#define NONCE_SIZE                  0x20        /**< Half of decoded 'nc' field */
+#define MSIM_READ_BUF_SIZE          (15 * 1024) /**< Receive buffer size */
+#define MSIM_FINAL_STRING           "\\final\\" /**< Message end marker */
+
+/* Messages */
+#define MSIM_BM_INSTANT             1
+#define MSIM_BM_STATUS              100
+#define MSIM_BM_ACTION              121
+#define MSIM_BM_MEDIA               122
+#define MSIM_BM_PROFILE             124
+#define MSIM_BM_UNOFFICIAL_CLIENT   200
+
+/* Authentication algorithm for login2 */
+#define MSIM_AUTH_ALGORITHM         196610
+
+/* Recognized challenge length */
+#define MSIM_AUTH_CHALLENGE_LENGTH  0x40
+
+/* TODO: obtain IPs of network interfaces from user's machine, instead of
+ * hardcoding these values below (used in msim_compute_login_response). 
+ * This is not immediately
+ * important because you can still connect and perform basic
+ * functions of the protocol. There is also a high chance that the addreses
+ * are RFC1918 private, so the servers couldn't do anything with them
+ * anyways except make note of that fact. Probably important for any
+ * kind of direct connection, or file transfer functionality.
+ */
+
+#define MSIM_LOGIN_IP_LIST  "\x00\x00\x00\x00\x05\x7f\x00\x00\x01\x00\x00\x00\x00\x0a\x00\x00\x40\xc0\xa8\x58\x01\xc0\xa8\x3c\x01"
+#define MSIM_LOGIN_IP_LIST_LEN         25
+
+/* Indexes into status string (0|1|2|3|..., but 0 always empty) */
+#define MSIM_STATUS_ORDINAL_EMPTY       0
+#define MSIM_STATUS_ORDINAL_UNKNOWNs    1
+#define MSIM_STATUS_ORDINAL_ONLINE      2
+#define MSIM_STATUS_ORDINAL_UNKNOWNss   3
+#define MSIM_STATUS_ORDINAL_HEADLINE    4
+#define MSIM_STATUS_ORDINAL_UNKNOWNls   5
+#define MSIM_STATUS_ORDINAL_UNKNOWN     6
+#define MSIM_STATUS_ORDINAL_UNKNOWN1    7
+#define MSIM_STATUS_ORDINAL_UNKNOWNp    8
+#define MSIM_STATUS_ORDINAL_UNKNOWN2    9
+
+/* Status codes - states a buddy (or you!) can be in. */
+#define MSIM_STATUS_CODE_OFFLINE_OR_HIDDEN    0
+#define MSIM_STATUS_CODE_ONLINE               1
+#define MSIM_STATUS_CODE_IDLE                 2
+#define MSIM_STATUS_CODE_AWAY                 5
+
+/* Text formatting bits for <f s=#> */
+#define MSIM_TEXT_BOLD                  1
+#define MSIM_TEXT_ITALIC                2   
+#define MSIM_TEXT_UNDERLINE             4
+
+/* Default baseline size of purple's fonts, in points. What is size 3 in points. 
+ * _font_scale specifies scaling factor relative to this point size. Note this 
+ * is only the default; it is configurable in account options. */
+#define MSIM_BASE_FONT_POINT_SIZE       8
+
+/* Default display's DPI. 96 is common but it can differ. Also configurable
+ * in account options. */
+#define MSIM_DEFAULT_DPI                96
+
+
+/* Random number in every MsimSession, to ensure it is valid. */
+#define MSIM_SESSION_STRUCT_MAGIC       0xe4a6752b
+
+/* Inbox status bitfield values for MsimSession.inbox_status */
+#define MSIM_INBOX_MAIL                 (1 << 0)
+#define MSIM_INBOX_BLOG_COMMENT         (1 << 1)
+#define MSIM_INBOX_PROFILE_COMMENT      (1 << 2)
+#define MSIM_INBOX_FRIEND_REQUEST       (1 << 3)
+#define MSIM_INBOX_PICTURE_COMMENT      (1 << 4)
+
+/* Everything needed to keep track of a session (proto_data field in PurpleConnection) */
+typedef struct _MsimSession
+{
+	guint magic;                        /**< MSIM_SESSION_STRUCT_MAGIC */
+	PurpleAccount *account;
+	PurpleConnection *gc;
+	guint sesskey;                      /**< Session key from server */
+	guint userid;                       /**< This user's numeric user ID */
+	gchar *username;                    /**< This user's unique username */
+	gint fd;                            /**< File descriptor to/from server */
+
+	/* TODO: Remove. */
+	GHashTable *user_lookup_cb;         /**< Username -> userid lookup callback */
+	GHashTable *user_lookup_cb_data;    /**< Username -> userid lookup callback data */
+
+	MsimMessage *server_info;           /**< Parameters from server */
+
+	gchar *rxbuf;                       /**< Receive buffer */
+	guint rxoff;                        /**< Receive buffer offset */
+	guint next_rid;                     /**< Next request/response ID */
+	time_t last_comm;                   /**< Time received last communication */
+	guint inbox_status;                 /**< Bit field of inbox notifications */
+} MsimSession;
+
+/* Check if an MsimSession is valid */
+#define MSIM_SESSION_VALID(s) (session != NULL && session->magic == MSIM_SESSION_STRUCT_MAGIC)
+
+/* Hold ephemeral information about buddies, for proto_data of PurpleBuddy. */
+/* GHashTable? */
+typedef struct _MsimUser
+{
+	PurpleBuddy *buddy;
+	guint client_cv;
+	gchar *client_info;
+	guint age;
+	gchar *gender;
+	gchar *location;
+	guint total_friends;
+	gchar *headline;
+	gchar *display_name;
+	/* Note: uid is in &buddy->node (set_blist_node_int), since it never changes */
+	gchar *username;
+	gchar *band_name, *song_name;
+	gchar *image_url;
+} MsimUser;
+
+
+#ifdef MSIM_USE_ATTENTION_API
+#define MsimAttentionType PurpleAttentionType
+#else
+/* Different kinds of attention alerts. Not yet in libpurple, so define 
+ * our own structure here. */
+typedef struct _MsimAttentionType MsimAttentionType;
+
+/** A type of "attention" message (zap, nudge, buzz, etc. depending on the
+ * protocol) that can be sent and received. */
+struct _MsimAttentionType {
+	PurpleStoredImage *icon;
+	const gchar *description;		/**< Shown before sending. */
+	const gchar *incoming_description;	/**< Shown when sent. */
+	const gchar *outgoing_description;	/**< Shown when received. */
+};
+#endif
+
+gchar *str_replace(const gchar *str, const gchar *old, const gchar *new);
+
+/* Callback function pointer type for when a user's information is received, 
+ * initiated from a user lookup. */
+typedef void (*MSIM_USER_LOOKUP_CB)(MsimSession *session, MsimMessage *userinfo, gpointer data);
+
+/* Functions */
+gboolean msim_load(PurplePlugin *plugin);
+GList *msim_status_types(PurpleAccount *acct);
+
+GList *msim_attention_types(PurpleAccount *acct);
+gboolean msim_send_attention(PurpleConnection *gc, gchar *username, guint code);
+
+GList *msim_blist_node_menu(PurpleBlistNode *node);
+
+const gchar *msim_list_icon(PurpleAccount *acct, PurpleBuddy *buddy);
+
+gboolean msim_send_raw(MsimSession *session, const gchar *msg);
+
+void msim_login(PurpleAccount *acct);
+
+int msim_send_im(PurpleConnection *gc, const gchar *who, const gchar *message, 
+PurpleMessageFlags flags);
+
+typedef void (*MSIM_XMLNODE_CONVERT)(MsimSession *, xmlnode *, gchar **, gchar **);
+
+unsigned int msim_send_typing(PurpleConnection *gc, const gchar *name, PurpleTypingState state);
+void msim_get_info(PurpleConnection *gc, const gchar *name);
+
+void msim_set_status(PurpleAccount *account, PurpleStatus *status);
+void msim_set_idle(PurpleConnection *gc, int time);
+
+void msim_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group);
+void msim_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group);
+
+gboolean msim_offline_message(const PurpleBuddy *buddy);
+
+MsimSession *msim_session_new(PurpleAccount *acct);
+void msim_session_destroy(MsimSession *session);
+
+void msim_close(PurpleConnection *gc);
+
+char *msim_status_text(PurpleBuddy *buddy);
+void msim_tooltip_text(PurpleBuddy *buddy, PurpleNotifyUserInfo *user_info, gboolean full);
+GList *msim_actions(PurplePlugin *plugin, gpointer context);
+
+#ifdef MSIM_SELF_TEST
+void msim_test_all(void) __attribute__((__noreturn__));
+int msim_test_msg(void);
+int msim_test_escaping(void);
+#endif
+
+void init_plugin(PurplePlugin *plugin);
+
+#endif /* !_MYSPACE_MYSPACE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/persist.h	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,90 @@
+/* MySpaceIM Protocol Plugin, persist commands
+ *
+ * Copyright (C) 2007, Jeff Connelly <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _MYSPACE_PERSIST_H
+#define _MYSPACE_PERSIST_H
+
+/** Command codes */
+#define MSIM_CMD_GET               1
+#define MSIM_CMD_PUT               2
+#define MSIM_CMD_DELETE            3
+
+/** Command bit fields */
+#define MSIM_CMD_BIT_CODE          255        /*< Bits specifying command code */
+#define MSIM_CMD_BIT_REPLY         256        /**< 1=reply, 0=request */
+#define MSIM_CMD_BIT_ACTION        512        /**< 1=action, 0=information */
+#define MSIM_CMD_BIT_ERROR        1024        /**< 1=error, 0=normal */
+
+/** Macros to read cmd bitfield. */
+#define MSIM_CMD_GET_CODE(x)      (x & MSIM_CMD_BIT_CODE)
+#define MSIM_CMD_IS_REPLY(x)      (x & MSIM_CMD_BIT_REPLY)
+#define MSIM_CMD_IS_REQUEST(x)   !(x & MSIM_CMD_BIT_REPLY)
+#define MSIM_CMD_IS_ACTION(x)     (x & MSIM_CMD_BIT_ACTION)
+#define MSIM_CMD_IS_INFO(x)      !(x & MSIM_CMD_BIT_ACTION)
+#define MSIM_CMD_IS_ERROR(x)      (x & MSIM_CMD_BIT_ERROR)
+#define MSIM_CMD_IS_NORMAL(x)    !(x & MSIM_CMD_BIT_ERROR)
+
+/** Define a set of _DSN and _LID constants for a persistance request. */
+#define MSIM_PERSIST_DSN_LID(name,dsn,lid)             \
+    const int name##_DSN = dsn;                        \
+    const int name##_LID = lid;                        
+
+/* Can't do this, errors:
+ *     persist.h:51:3: error: '#' is not followed by a macro parameter
+ *  In file included from myspace.c:37:
+ *  persist.h:56: error: expected ')' before numeric constant
+ * So instead, I define const ints above.
+#define MSIM_PERSIST_DSN_LID(name,dsn,lid)             \
+	#define name##_DSN        dsn                  \
+	#define name##_LID        lid
+#endif
+*/
+
+/** Messages to Get information                dsn lid */
+MSIM_PERSIST_DSN_LID(MG_LIST_ALL_CONTACTS,         0, 1)
+MSIM_PERSIST_DSN_LID(MG_USER_INFO_BY_ID,           0, 2)
+MSIM_PERSIST_DSN_LID(MG_OWN_IM_INFO,               1, 4)
+MSIM_PERSIST_DSN_LID(MG_IM_INFO_BY_ID,             1, 17)
+MSIM_PERSIST_DSN_LID(MG_LIST_ALL_GROUPS,           2, 6)
+MSIM_PERSIST_DSN_LID(MG_MYSPACE_INFO_BY_ID,        4, 3)
+MSIM_PERSIST_DSN_LID(MG_OWN_MYSPACE_INFO,          4, 5)
+MSIM_PERSIST_DSN_LID(MG_MYSPACE_INFO_BY_STRING,    5, 7)
+MSIM_PERSIST_DSN_LID(MG_CHECK_MAIL,                7, 18)
+MSIM_PERSIST_DSN_LID(MG_WEB_CHALLENGE,            17, 26)
+MSIM_PERSIST_DSN_LID(MG_USER_SONG,                21, 28)
+MSIM_PERSIST_DSN_LID(MG_SERVER_INFO,             101, 20)
+
+/** Messages to Change/send information */
+MSIM_PERSIST_DSN_LID(MC_USER_PREFERENCES,          1, 10)
+MSIM_PERSIST_DSN_LID(MC_CONTACT_INFO,              0, 9)
+MSIM_PERSIST_DSN_LID(MC_IMPORT_ALL_FRIENDS,        14, 21)
+MSIM_PERSIST_DSN_LID(MC_INVITE,                   16, 25)
+
+/** Messages to Delete information */
+MSIM_PERSIST_DSN_LID(MD_DELETE_BUDDY,              0, 8)
+
+/** Error codes */
+#define MERR_PARSE                    1
+#define MERR_NOT_LOGGED_IN            2
+#define MERR_ANOTHER_LOGIN            6
+#define MERR_BAD_EMAIL                259
+#define MERR_BAD_PASSWORD             260
+#define MERR_BAD_UID_IN_PERSISTR      4352
+
+#endif /* !_MYSPACE_PERSIST_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/myspace/release.sh	Tue Aug 21 07:12:51 2007 +0000
@@ -0,0 +1,48 @@
+#!/bin/bash
+# Created:20070618
+# By Jeff Connelly
+
+# Package a new msimprpl for release. Must be run with bash.
+
+VERSION=0.14
+make
+# Include 'myspace' directory in archive, so it can easily be unextracted
+# into ~/pidgin/libpurple/protocols at the correct location.
+# (if this command fails, run it manually).
+# This convenient command requires bash.
+cd ../../..
+tar -cf libpurple/protocols/msimprpl-$VERSION.tar libpurple/protocols/myspace/{CHANGES,ChangeLog,LICENSE,Makefile.*,*.c,*.h,README,release.sh,.deps/*} autogen.sh configure.ac
+cd libpurple/protocols/myspace
+gzip ../msimprpl-$VERSION.tar
+
+mv ~/pidgin/config.h ~/pidgin/config.h-
+make -f Makefile.mingw
+mv ~/pidgin/config.h- ~/pidgin/config.h
+cp ~/pidgin/win32-install-dir/plugins/libmyspace.dll .
+# Zip is more common with Win32 users. Just include a few files in this archive,
+# but (importantly) preserve the install directory structure!
+mkdir -p win32-archive/plugins
+cp libmyspace.dll win32-archive/plugins
+mkdir -p win32-archive/pixmaps/pidgin/protocols/{48,22,16}
+cp ~/pidgin/win32-install-dir/pixmaps/pidgin/protocols/48/myspace.png \
+                win32-archive/pixmaps/pidgin/protocols/48/
+cp ~/pidgin/win32-install-dir/pixmaps/pidgin/protocols/22/myspace.png \
+                win32-archive/pixmaps/pidgin/protocols/22/
+cp ~/pidgin/win32-install-dir/pixmaps/pidgin/protocols/16/myspace.png \
+                win32-archive/pixmaps/pidgin/protocols/16/
+mkdir -p win32-archive/pixmaps/pidgin/emotes/default
+cp ~/pidgin/win32-install-dir/pixmaps/pidgin/emotes/default/theme \
+        win32-archive/pixmaps/pidgin/emotes/default/theme
+# Emoticons in MySpaceIM but not Pidgin 2.1.0
+cp ~/pidgin/win32-install-dir/pixmaps/pidgin/emotes/default/{sinister,sidefrown,pirate,mohawk,messed,bulgy-eyes}.png \
+	win32-archive/pixmaps/pidgin/emotes/default/
+
+# Use DOS line endings and .txt file extension for convenience
+u2d < README > win32-archive/msimprpl-README.txt
+u2d < LICENSE > win32-archive/msimprpl-LICENSE.txt
+u2d < CHANGES > win32-archive/msimprpl-CHANGES.txt
+cd win32-archive
+zip -r ../../msimprpl-$VERSION-win32.zip *
+cd ..
+rm -rf win32-archive
+ls -l ../msimprpl-$VERSION*

--- a/libpurple/protocols/yahoo/yahoo.c	Tue Aug 21 00:05:40 2007 +0000
+++ b/libpurple/protocols/yahoo/yahoo.c	Tue Aug 21 07:12:51 2007 +0000
@@ -3723,10 +3723,10 @@
 	struct yahoo_data *yd = (struct yahoo_data *)gc->proto_data;
 	struct yahoo_packet *pkt;
 	PurpleGroup *g;
-	char *group = NULL;
-	char *group2 = NULL;
+	const char *group = NULL;
+	char *group2;
 	YahooFriend *f;
-	
+
 	if (!yd->logged_in)
 		return;
 

--- a/libpurple/protocols/yahoo/yahoo_friend.c	Tue Aug 21 00:05:40 2007 +0000
+++ b/libpurple/protocols/yahoo/yahoo_friend.c	Tue Aug 21 07:12:51 2007 +0000
@@ -196,6 +196,8 @@
 	struct yahoo_data *yd = gc->proto_data;
 	struct yahoo_packet *pkt = NULL;
 	YahooFriend *f;
+	const char *thirtyone, *thirteen;
+	int service = -1;
 
 	if (!yd->logged_in)
 		return;
@@ -211,44 +213,48 @@
 	}
 
 	if (presence == YAHOO_PRESENCE_PERM_OFFLINE) {
-		pkt = yahoo_packet_new(YAHOO_SERVICE_PRESENCE_PERM,
-				YAHOO_STATUS_AVAILABLE, yd->session_id);
-
-		yahoo_packet_hash(pkt, "ssss",
-				1, purple_connection_get_display_name(gc),
-				31, "1", 13, "2", 7, name);
+		service = YAHOO_SERVICE_PRESENCE_PERM;
+		thirtyone = "1";
+		thirteen = "2";
 	} else if (presence == YAHOO_PRESENCE_DEFAULT) {
 		if (f->presence == YAHOO_PRESENCE_PERM_OFFLINE) {
-			pkt = yahoo_packet_new(YAHOO_SERVICE_PRESENCE_PERM,
-					YAHOO_STATUS_AVAILABLE, yd->session_id);
-
-			yahoo_packet_hash(pkt, "ssss",
-					1, purple_connection_get_display_name(gc),
-					31, "2", 13, "2", 7, name);
+			service = YAHOO_SERVICE_PRESENCE_PERM;
+			thirtyone = "2";
+			thirteen = "2";
 		} else if (yd->current_status == YAHOO_STATUS_INVISIBLE) {
-			pkt = yahoo_packet_new(YAHOO_SERVICE_PRESENCE_SESSION,
-					YAHOO_STATUS_AVAILABLE, yd->session_id);
-			yahoo_packet_hash(pkt, "ssss",
-				1, purple_connection_get_display_name(gc),
-				31, "2", 13, "1", 7, name);
+			service = YAHOO_SERVICE_PRESENCE_SESSION;
+			thirtyone = "2";
+			thirteen = "1";
 		}
 	} else if (presence == YAHOO_PRESENCE_ONLINE) {
 		if (f->presence == YAHOO_PRESENCE_PERM_OFFLINE) {
 			pkt = yahoo_packet_new(YAHOO_SERVICE_PRESENCE_PERM,
 					YAHOO_STATUS_AVAILABLE, yd->session_id);
-			yahoo_packet_hash(pkt, "ssss",
+			yahoo_packet_hash(pkt, "ssssssss",
 					1, purple_connection_get_display_name(gc),
-					31, "2", 13, "2", 7, name);
+					31, "2", 13, "2",
+					302, "319", 300, "319",
+					7, name,
+					301, "319", 303, "319");
 			yahoo_packet_send_and_free(pkt, yd);
 		}
 
-		pkt = yahoo_packet_new(YAHOO_SERVICE_PRESENCE_SESSION,
-				YAHOO_STATUS_AVAILABLE, yd->session_id);
-		yahoo_packet_hash(pkt, "ssss",
-				1, purple_connection_get_display_name(gc),
-				31, "1", 13, "1", 7, name);
+		service = YAHOO_SERVICE_PRESENCE_SESSION;
+		thirtyone = "1";
+		thirteen = "1";
 	}
 
-	if (pkt)
+	if (service > 0) {
+		pkt = yahoo_packet_new(service,
+				YAHOO_STATUS_AVAILABLE, yd->session_id);
+
+		yahoo_packet_hash(pkt, "ssssssss",
+				1, purple_connection_get_display_name(gc),
+				31, thirtyone, 13, thirteen,
+				302, "319", 300, "319",
+				7, name,
+				301, "319", 303, "319");
+
 		yahoo_packet_send_and_free(pkt, yd);
+	}
 }

--- a/libpurple/purple-url-handler	Tue Aug 21 00:05:40 2007 +0000
+++ b/libpurple/purple-url-handler	Tue Aug 21 07:12:51 2007 +0000
@@ -44,6 +44,12 @@
     else:
         return list
 
+def convert(value):
+    try:
+        return int(value)
+    except:
+        return value
+
 def findaccount(protocolname, accountname=""):
     # prefer connected accounts
     account = cpurple.PurpleAccountsFindConnected(accountname, protocolname)
@@ -84,6 +90,32 @@
     cpurple.PurpleBlistRequestAddBuddy(account, screenname, group, alias)
 
 
+def aim(uri):
+    protocol = "prpl-aim"
+    match = re.match(r"^aim:([^?]*)(\?(.*))", uri)
+    if not match:
+        print "Invalid aim URI: %s" % uri
+        return
+
+    command = urllib.unquote_plus(match.group(1))
+    paramstring = match.group(3)
+    params = {}
+    if paramstring:
+        for param in paramstring.split("&"):
+            key, value = extendlist(param.split("=", 1), 2, "")
+            params[key] = urllib.unquote_plus(value)
+    accountname = params.get("account", "")
+    screenname = params.get("screenname", "")
+
+    account = findaccount(protocol, accountname)
+
+    if command.lower() == "goim":
+        goim(account, screenname, params.get("message"))
+    elif command.lower() == "gochat":
+        gochat(account, params)
+    elif command.lower() == "addbuddy":
+        addbuddy(account, screenname, params.get("group", ""))
+
 def gg(uri):
     protocol = "prpl-gg"
     match = re.match(r"^gg:(.*)", uri)
@@ -95,6 +127,32 @@
     account = findaccount(protocol)
     goim(account, screenname)
 
+def icq(uri):
+    protocol = "prpl-icq"
+    match = re.match(r"^icq:([^?]*)(\?(.*))", uri)
+    if not match:
+        print "Invalid icq URI: %s" % uri
+        return
+
+    command = urllib.unquote_plus(match.group(1))
+    paramstring = match.group(3)
+    params = {}
+    if paramstring:
+        for param in paramstring.split("&"):
+            key, value = extendlist(param.split("=", 1), 2, "")
+            params[key] = urllib.unquote_plus(value)
+    accountname = params.get("account", "")
+    screenname = params.get("screenname", "")
+
+    account = findaccount(protocol, accountname)
+
+    if command.lower() == "goim":
+        goim(account, screenname, params.get("message"))
+    elif command.lower() == "gochat":
+        gochat(account, params)
+    elif command.lower() == "addbuddy":
+        addbuddy(account, screenname, params.get("group", ""))
+
 def irc(uri):
     protocol = "prpl-irc"
     match = re.match(r"^irc:(//([^/]*)/)?([^?]*)(\?(.*))?", uri)
@@ -131,6 +189,34 @@
                 channel = "#" + channel
             gochat(account, {"server": server, "channel": channel, "password": params.get("key", "")}, params.get("msg"))
 
+def msnim(uri):
+    protocol = "prpl-msn"
+    match = re.match(r"^msnim:([^?]*)(\?(.*))", uri)
+    if not match:
+        print "Invalid msnim URI: %s" % uri
+        return
+
+    command = urllib.unquote_plus(match.group(1))
+    paramstring = match.group(3)
+    params = {}
+    if paramstring:
+        for param in paramstring.split("&"):
+            key, value = extendlist(param.split("=", 1), 2, "")
+            params[key] = urllib.unquote_plus(value)
+    screenname = params.get("contact", "")
+
+    account = findaccount(protocol)
+
+    if command.lower() == "chat":
+        goim(account, screenname)
+    elif command.lower() == "add":
+        addbuddy(account, screenname)
+
+def myim(uri):
+	protocol = "prpl-myspace"
+	print "TODO: send uri: ", uri
+	assert False, "Not implemented"
+
 def sip(uri):
     protocol = "prpl-simple"
     match = re.match(r"^sip:(.*)", uri)
@@ -182,6 +268,32 @@
     else:
         goim(account, screenname)
 
+def ymsgr(uri):
+    protocol = "prpl-yahoo"
+    match = re.match(r"^ymsgr:([^?]*)(\?([^&]*)(&(.*))?)", uri)
+    if not match:
+        print "Invalid ymsgr URI: %s" % uri
+        return
+
+    command = urllib.unquote_plus(match.group(1))
+    screenname = urllib.unquote_plus(match.group(3))
+    paramstring = match.group(5)
+    params = {}
+    if paramstring:
+        for param in paramstring.split("&"):
+            key, value = extendlist(param.split("=", 1), 2, "")
+            params[key] = urllib.unquote_plus(value)
+
+    account = findaccount(protocol)
+
+    if command.lower() == "sendim":
+        goim(account, screenname, params.get("m"))
+    elif command.lower() == "chat":
+        gochat(account, {"room": screenname})
+    elif command.lower() == "addfriend":
+        addbuddy(account, screenname)
+
+
 def main(argv=sys.argv):
     if len(argv) != 2:
         print "Usage: %s URI" % argv[0]
@@ -192,16 +304,26 @@
     type = uri.split(":")[0]
 
     try:
-        if type == "gg":
+        if type == "aim":
+            aim(uri)
+        elif type == "gg":
             gg(uri)
+        elif type == "icq":
+            icq(uri)
         elif type == "irc":
             irc(uri)
+        elif type == "msnim":
+            msnim(uri)
+        elif type == "myim":
+            myim(uri)
         elif type == "sip":
             sip(uri)
         elif type == "xmpp":
             xmpp(uri)
+        elif type == "ymsgr":
+            ymsgr(uri)
         else:
-            cpurple.PurpleGotProtocolHandlerUri(uri)
+            print "Unknown protocol: %s" % type
     except dbus.dbus_bindings.DBusException:
         print "ERROR: Is there a libpurple-powered client (e.g. Pidgin or Finch) running?"
 

--- a/pidgin/pixmaps/protocols/16/Makefile.am	Tue Aug 21 00:05:40 2007 +0000
+++ b/pidgin/pixmaps/protocols/16/Makefile.am	Tue Aug 21 07:12:51 2007 +0000
@@ -10,6 +10,7 @@
 		jabber.png \
 		meanwhile.png \
 		msn.png \
+		myspace.png \
 		qq.png \
 		silc.png \
 		simple.png \

Binary file pidgin/pixmaps/protocols/16/myspace.png has changed

--- a/pidgin/pixmaps/protocols/22/Makefile.am	Tue Aug 21 00:05:40 2007 +0000
+++ b/pidgin/pixmaps/protocols/22/Makefile.am	Tue Aug 21 07:12:51 2007 +0000
@@ -10,6 +10,7 @@
 		jabber.png \
 		meanwhile.png \
 		msn.png \
+		myspace.png \
 		qq.png \
 		silc.png \
 		simple.png \

Binary file pidgin/pixmaps/protocols/22/myspace.png has changed

--- a/pidgin/pixmaps/protocols/48/Makefile.am	Tue Aug 21 00:05:40 2007 +0000
+++ b/pidgin/pixmaps/protocols/48/Makefile.am	Tue Aug 21 07:12:51 2007 +0000
@@ -9,6 +9,7 @@
 		jabber.png \
 		meanwhile.png \
 		msn.png \
+		myspace.png \
 		qq.png \
 		silc.png \
 		simple.png \

Binary file pidgin/pixmaps/protocols/48/myspace.png has changed

--- a/pidgin/plugins/win32/transparency/win2ktrans.c	Tue Aug 21 00:05:40 2007 +0000
+++ b/pidgin/plugins/win32/transparency/win2ktrans.c	Tue Aug 21 07:12:51 2007 +0000
@@ -396,8 +396,12 @@
 			&& pconv->unseen_state == PIDGIN_UNSEEN_NONE
 			&& pidgin_conv_window_get_gtkconv_count(win) == 1) {
 		GtkWidget *window = win->window;
+		gboolean has_focus;
 
-		set_conv_window_trans(NULL, win);
+		g_object_get(G_OBJECT(window), "has-toplevel-focus", &has_focus, NULL);
+
+		if (!has_focus)
+			set_conv_window_trans(NULL, win);
 
 		if (g_signal_handler_find(G_OBJECT(window), G_SIGNAL_MATCH_FUNC,
 				0, 0, NULL, G_CALLBACK(focus_conv_win_cb), NULL) == 0) {

--- a/po/POTFILES.in	Tue Aug 21 00:05:40 2007 +0000
+++ b/po/POTFILES.in	Tue Aug 21 07:12:51 2007 +0000
@@ -96,6 +96,7 @@
 libpurple/protocols/msn/state.c
 libpurple/protocols/msn/switchboard.c
 libpurple/protocols/msn/userlist.c
+libpurple/protocols/myspace/myspace.c
 libpurple/protocols/novell/nmuser.c
 libpurple/protocols/novell/novell.c
 libpurple/protocols/oscar/flap_connection.c